View Javadoc
1   /*******************************************************************************
2    * Copyright 2012 Internet2
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    *   http://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   ******************************************************************************/
16  /*
17   * @author mchyzer
18   * $Id$
19   */
20  package edu.internet2.middleware.grouperClient.poc;
21  
22  import java.io.ByteArrayOutputStream;
23  import java.io.File;
24  import java.io.PrintStream;
25  import java.sql.Timestamp;
26  import java.util.ArrayList;
27  import java.util.Arrays;
28  import java.util.Date;
29  import java.util.List;
30  import java.util.Set;
31  import java.util.regex.Matcher;
32  import java.util.regex.Pattern;
33  
34  import junit.textui.TestRunner;
35  
36  import org.apache.commons.lang.StringUtils;
37  import org.apache.commons.lang.exception.ExceptionUtils;
38  
39  import edu.internet2.middleware.grouper.FieldFinder;
40  import edu.internet2.middleware.grouper.FieldType;
41  import edu.internet2.middleware.grouper.Group;
42  import edu.internet2.middleware.grouper.GroupFinder;
43  import edu.internet2.middleware.grouper.GroupSave;
44  import edu.internet2.middleware.grouper.GroupType;
45  import edu.internet2.middleware.grouper.GroupTypeFinder;
46  import edu.internet2.middleware.grouper.GrouperSession;
47  import edu.internet2.middleware.grouper.Member;
48  import edu.internet2.middleware.grouper.MemberFinder;
49  import edu.internet2.middleware.grouper.Membership;
50  import edu.internet2.middleware.grouper.MembershipFinder;
51  import edu.internet2.middleware.grouper.Stem;
52  import edu.internet2.middleware.grouper.StemFinder;
53  import edu.internet2.middleware.grouper.StemSave;
54  import edu.internet2.middleware.grouper.SubjectFinder;
55  import edu.internet2.middleware.grouper.attr.AttributeDef;
56  import edu.internet2.middleware.grouper.attr.AttributeDefName;
57  import edu.internet2.middleware.grouper.attr.AttributeDefNameSave;
58  import edu.internet2.middleware.grouper.attr.AttributeDefNameTest;
59  import edu.internet2.middleware.grouper.attr.AttributeDefSave;
60  import edu.internet2.middleware.grouper.attr.AttributeDefTest;
61  import edu.internet2.middleware.grouper.attr.AttributeDefType;
62  import edu.internet2.middleware.grouper.attr.AttributeDefValueType;
63  import edu.internet2.middleware.grouper.attr.assign.AttributeAssign;
64  import edu.internet2.middleware.grouper.attr.assign.AttributeAssignResult;
65  import edu.internet2.middleware.grouper.attr.finder.AttributeDefFinder;
66  import edu.internet2.middleware.grouper.attr.finder.AttributeDefNameFinder;
67  import edu.internet2.middleware.grouper.cfg.GrouperConfig;
68  import edu.internet2.middleware.grouper.changeLog.ChangeLogTempToEntity;
69  import edu.internet2.middleware.grouper.externalSubjects.ExternalSubject;
70  import edu.internet2.middleware.grouper.externalSubjects.ExternalSubjectSave;
71  import edu.internet2.middleware.grouper.group.TypeOfGroup;
72  import edu.internet2.middleware.grouper.helper.GroupHelper;
73  import edu.internet2.middleware.grouper.helper.GrouperTest;
74  import edu.internet2.middleware.grouper.helper.SessionHelper;
75  import edu.internet2.middleware.grouper.helper.SubjectTestHelper;
76  import edu.internet2.middleware.grouper.internal.dao.QueryOptions;
77  import edu.internet2.middleware.grouper.messaging.GrouperBuiltinMessagingSystem;
78  import edu.internet2.middleware.grouper.misc.CompositeType;
79  import edu.internet2.middleware.grouper.misc.SaveMode;
80  import edu.internet2.middleware.grouper.permissions.role.Role;
81  import edu.internet2.middleware.grouper.privs.AccessPrivilege;
82  import edu.internet2.middleware.grouper.privs.AttributeDefPrivilege;
83  import edu.internet2.middleware.grouper.privs.NamingPrivilege;
84  import edu.internet2.middleware.grouper.util.GrouperUtil;
85  import edu.internet2.middleware.grouper.ws.util.RestClientSettings;
86  import edu.internet2.middleware.grouperClient.GrouperClient;
87  import edu.internet2.middleware.grouperClient.api.GcGetGroups;
88  import edu.internet2.middleware.grouperClient.api.GcGroupSave;
89  import edu.internet2.middleware.grouperClient.messaging.GrouperMessage;
90  import edu.internet2.middleware.grouperClient.messaging.GrouperMessageQueueType;
91  import edu.internet2.middleware.grouperClient.messaging.GrouperMessageReceiveParam;
92  import edu.internet2.middleware.grouperClient.messaging.GrouperMessageReceiveResult;
93  import edu.internet2.middleware.grouperClient.messaging.GrouperMessageSendParam;
94  import edu.internet2.middleware.grouperClient.messaging.GrouperMessagingEngine;
95  import edu.internet2.middleware.grouperClient.util.GrouperClientConfig;
96  import edu.internet2.middleware.grouperClient.util.GrouperClientUtils;
97  import edu.internet2.middleware.grouperClient.ws.GcWebServiceError;
98  import edu.internet2.middleware.grouperClient.ws.GrouperClientWs;
99  import edu.internet2.middleware.grouperClient.ws.beans.WsGetGroupsResults;
100 import edu.internet2.middleware.grouperClient.ws.beans.WsGroup;
101 import edu.internet2.middleware.grouperClient.ws.beans.WsGroupLookup;
102 import edu.internet2.middleware.grouperClient.ws.beans.WsGroupSaveResults;
103 import edu.internet2.middleware.grouperClient.ws.beans.WsGroupToSave;
104 import edu.internet2.middleware.grouperClient.ws.beans.WsMemberChangeSubjectResults;
105 import edu.internet2.middleware.subject.Subject;
106 
107 /**
108  *
109  */
110 public class GrouperClientWsTest extends GrouperTest {
111 
112   /**
113    *
114    * @param args
115    */
116   public static void main(String[] args) {
117     TestRunner.run(new GrouperClientWsTest("testExternalSubjectSave"));
118     //TestRunner.run(new GrouperClientWsTest("testGroupSaveLookupNameSame"));
119     //TestRunner.run(new GrouperClientWsTest("testGroupSaveNoLookup"));
120   }
121 
122   /**
123    *
124    * @see edu.internet2.middleware.grouper.helper.GrouperTest#setUp()
125    */
126   @Override
127   protected void setUp() {
128 
129     // dont do this, it deletes types
130     // super.setUp();
131 
132     String wsUserLabel = GrouperClientConfig.retrieveConfig().propertyValueStringRequired(
133         "grouperClient.webService.user.label");
134     String wsUserString = GrouperClientConfig.retrieveConfig().propertyValueStringRequired(
135         "grouperClient.webService." + wsUserLabel);
136 
137     RestClientSettings.resetData(wsUserString, false);
138 
139     GrouperConfig.retrieveConfig().propertiesOverrideMap().put("groups.create.grant.all.read", "true");
140     GrouperConfig.retrieveConfig().propertiesOverrideMap().put("groups.create.grant.all.view", "true");
141 
142     GrouperClientConfig.retrieveConfig().propertiesOverrideMap().put("encrypt.key",
143         "sdfklj24lkj34lk34");
144     GrouperClientConfig.retrieveConfig().propertiesOverrideMap().put(
145         "encrypt.disableExternalFileLookup", "false");
146 
147     GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
148         .put(
149             "webService.addMember.output",
150             "Index ${index}: success: ${resultMetadata.success}: code: ${resultMetadata.resultCode}: ${wsSubject.id}$newline$");
151     GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
152         .put(
153             "webService.getMembers.output",
154             "GroupIndex ${groupIndex}: success: ${resultMetadata.success}: code: ${resultMetadata.resultCode}: group: ${wsGroup.name}: subjectIndex: ${subjectIndex}: ${wsSubject.id}$newline$");
155     GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
156         .put(
157             "webService.deleteMember.output",
158             "Index ${index}: success: ${resultMetadata.success}: code: ${resultMetadata.resultCode}: ${wsSubject.id}$newline$");
159     GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
160         .put(
161             "webService.hasMember.output",
162             "Index ${index}: success: ${resultMetadata.success}: code: ${resultMetadata.resultCode}: ${wsSubject.id}: ${hasMember}$newline$");
163     GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
164         .put(
165             "webService.getGroups.output",
166             "SubjectIndex ${subjectIndex}: success: ${resultMetadata.success}: code: ${resultMetadata.resultCode}: subject: ${wsSubject.id}: groupIndex: ${groupIndex}: ${wsGroup.name}$newline$");
167     GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
168         .put(
169             "webService.groupSave.output",
170             "Success: ${resultMetadata.success}: code: ${resultMetadata.resultCode}: ${wsGroup.name}$newline$");
171     GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
172         .put(
173             "webService.stemSave.output",
174             "Success: ${resultMetadata.success}: code: ${resultMetadata.resultCode}: ${wsStem.name}$newline$");
175     GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
176         .put(
177             "webService.groupDelete.output",
178             "Index ${index}: success: ${resultMetadata.success}: code: ${resultMetadata.resultCode}: ${wsGroup.name}$newline$");
179     GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
180         .put(
181             "webService.stemDelete.output",
182             "Index ${index}: success: ${resultMetadata.success}: code: ${resultMetadata.resultCode}: ${wsStem.name}$newline$");
183     GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
184         .put(
185             "webService.getGrouperPrivilegesLite.output",
186             "Index ${index}: success: ${resultMetadata.success}: code: ${resultMetadata.resultCode}: ${objectType}: ${objectName}: subject: ${wsSubject.id}: ${wsGrouperPrivilegeResult.privilegeType}: ${wsGrouperPrivilegeResult.privilegeName}$newline$");
187     GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
188         .put(
189             "webService.assignGrouperPrivilegesLite.output",
190             "Success: ${resultMetadata.success}: code: ${resultMetadata.resultCode}: ${objectType}: ${objectName}: subject: ${wsSubject.id}: ${wsAssignGrouperPrivilegesLiteResult.privilegeType}: ${wsAssignGrouperPrivilegesLiteResult.privilegeName}$newline$");
191     GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
192         .put(
193             "webService.findGroups.output",
194             "Index ${index}: name: ${wsGroup.name}, displayName: ${wsGroup.displayName}$newline$");
195     GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
196         .put(
197             "webService.findStems.output",
198             "Index ${index}: name: ${wsStem.name}, displayName: ${wsStem.displayName}$newline$");
199     GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
200         .put(
201             "webService.memberChangeSubject.output",
202             "Success: ${resultMetadata.success}: code: ${resultMetadata.resultCode}: oldSubject: ${wsSubjectOld.id}, newSubject: ${wsSubjectNew.id}$newline$");
203 
204     GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
205     .put(
206         "webService.getSubjects.output",
207         "Index: ${index}: success: ${success}, code: ${wsSubject.resultCode}, subject: ${wsSubject.id}$newline$");
208 
209     GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
210     .put(
211         "webService.assignAttributeDefNameInheritance.output",
212         "Success: ${resultMetadata.success}: code: ${resultMetadata.resultCode}, message: ${resultMetadata.resultMessage}$newline$");
213     GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
214     .put(
215         "webService.attributeDefNameSave.output",
216         "Success: ${resultMetadata.success}: code: ${resultMetadata.resultCode}: ${wsAttributeDefName.name}$newline$");
217     GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
218     .put(
219         "webService.attributeDefNameDelete.output",
220         "Index ${index}: success: ${resultMetadata.success}: code: ${resultMetadata.resultCode}: ${wsAttributeDefName.name}$newline$");
221     GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
222     .put(
223         "webService.findAttributeDefNames.output",
224         "Index ${index}: name: ${wsAttributeDefName.name}, displayName: ${wsAttributeDefName.displayName}$newline$");
225 
226     GrouperClientConfig.retrieveConfig().propertiesOverrideMap().put(
227         "grouperClient.alias.subjectIds", "pennIds");
228     GrouperClientConfig.retrieveConfig().propertiesOverrideMap().put(
229         "grouperClient.alias.subjectIdentifiers", "pennKeys");
230     GrouperClientConfig.retrieveConfig().propertiesOverrideMap().put(
231         "grouperClient.alias.SubjectId", "PennId");
232     GrouperClientConfig.retrieveConfig().propertiesOverrideMap().put(
233         "grouperClient.alias.SubjectIdentifier", "PennKey");
234     GrouperClientConfig.retrieveConfig().propertiesOverrideMap().put(
235         "grouperClient.alias.subjectId", "pennId");
236     GrouperClientConfig.retrieveConfig().propertiesOverrideMap().put(
237         "grouperClient.alias.subjectIdentifier", "pennKey");
238 
239     GrouperClientConfig.retrieveConfig().propertiesOverrideMap()
240         .put(
241             "webService.hasMember.output",
242             "Index ${index}: success: ${wsHasMemberResult.resultMetadata.success}: code: ${wsHasMemberResult.resultMetadata.resultCode}: ${wsHasMemberResult.wsSubject.id}: ${hasMember}$newline$");
243 
244 
245     GrouperSession grouperSession = GrouperSession.startRootSession();
246 
247     Group group = GroupFinder.findByName(grouperSession, "aStem:aGroup4", false);
248 
249     if (group != null) {
250       group.delete();
251     }
252 
253     GrouperClient.exitOnError = false;
254   }
255 
256   /**
257    *
258    * @see edu.internet2.middleware.grouper.helper.GrouperTest#tearDown()
259    */
260   @Override
261   protected void tearDown() {
262 
263     GrouperClientConfig.retrieveConfig().propertiesOverrideMap().clear();
264 
265     super.tearDown();
266 
267   }
268 
269   /**
270    * @param name
271    */
272   public GrouperClientWsTest(String name) {
273     super(name);
274   }
275 
276   /**
277    * @throws Exception
278    */
279   public void testAddMember() throws Exception {
280 
281     // make sure group exists
282     // GrouperSession grouperSession = GrouperSession.startRootSession();
283     // Group group = Group.saveGroup(grouperSession, "aStem:aGroup", null,
284     // "aStem:aGroup", "aGroup", null, null, true);
285     //
286     // //give permissions
287     // String wsUserLabel =
288     // GrouperClientUtils.propertiesValue("grouperClient.webService.user.label",
289     // true);
290     // String wsUserString =
291     // GrouperClientUtils.propertiesValue("grouperClient.webService." +
292     // wsUserLabel, true);
293     // Subject wsUser = SubjectFinder.findByIdOrIdentifier(wsUserString, true);
294 
295     GrouperSession grouperSession = GrouperSession.startRootSession();
296     Group group = GroupFinder.findByName(grouperSession, "aStem:aGroup", true);
297 
298     PrintStream systemOut = System.out;
299 
300     ByteArrayOutputStream baos = new ByteArrayOutputStream();
301     System.setOut(new PrintStream(baos));
302 
303     try {
304 
305       GrouperClient
306           .main(GrouperClientUtils
307               .splitTrim(
308                   "--operation=addMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1",
309                   " "));
310       System.out.flush();
311       String output = new String(baos.toByteArray());
312 
313       System.setOut(systemOut);
314 
315       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
316 
317       Pattern pattern = Pattern
318           .compile("^Index (\\d+): success: T: code: ([A-Z_]+): (.*+)$");
319       Matcher matcher = pattern.matcher(outputLines[0]);
320 
321       assertTrue(outputLines[0], matcher.matches());
322 
323       assertEquals(outputLines[0], "0", matcher.group(1));
324       assertEquals(outputLines[0], "SUCCESS", matcher.group(2));
325       assertEquals(outputLines[0], "test.subject.0", matcher.group(3));
326 
327       matcher = pattern.matcher(outputLines[1]);
328 
329       assertTrue(outputLines[1], matcher.matches());
330 
331       assertEquals("1", matcher.group(1));
332       assertEquals("SUCCESS", matcher.group(2));
333       assertEquals("test.subject.1", matcher.group(3));
334 
335       // #####################################################
336       // run again, should be already added
337       baos = new ByteArrayOutputStream();
338       System.setOut(new PrintStream(baos));
339 
340       GrouperClient
341           .main(GrouperClientUtils
342               .splitTrim(
343                   "--operation=addMemberWs --groupName=aStem:aGroup --pennIds=test.subject.0,test.subject.1",
344                   " "));
345       System.out.flush();
346       output = new String(baos.toByteArray());
347 
348       System.setOut(systemOut);
349 
350       outputLines = GrouperClientUtils.splitTrim(output, "\n");
351 
352       matcher = pattern.matcher(outputLines[0]);
353 
354       assertTrue(outputLines[0], matcher.matches());
355 
356       assertEquals("0", matcher.group(1));
357       assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
358       assertEquals("test.subject.0", matcher.group(3));
359 
360       matcher = pattern.matcher(outputLines[1]);
361 
362       assertTrue(outputLines[1], matcher.matches());
363 
364       assertEquals("1", matcher.group(1));
365       assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
366       assertEquals("test.subject.1", matcher.group(3));
367 
368       // #####################################################
369       // run again, with enabled date
370       baos = new ByteArrayOutputStream();
371       System.setOut(new PrintStream(baos));
372 
373       GrouperClient
374           .main(GrouperClientUtils
375               .splitTrim(
376                   "--operation=addMemberWs --groupName=aStem:aGroup --pennIds=test.subject.0 --enabledTime=2010/02/03",
377                   " "));
378       System.out.flush();
379       output = new String(baos.toByteArray());
380 
381       System.setOut(systemOut);
382 
383       outputLines = GrouperClientUtils.splitTrim(output, "\n");
384 
385       matcher = pattern.matcher(outputLines[0]);
386 
387       assertTrue(outputLines[0], matcher.matches());
388 
389       assertEquals("0", matcher.group(1));
390       assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
391       assertEquals("test.subject.0", matcher.group(3));
392 
393       Membership membership = group.getImmediateMembership(Group.getDefaultList(), SubjectTestHelper.SUBJ0, false, true);
394       assertEquals(GrouperClientUtils.stringToDate("2010/02/03 00:00:00.000"), membership.getEnabledTime());
395       assertEquals(null, membership.getDisabledTime());
396 
397       // #####################################################
398       // run again, with disabled date
399       baos = new ByteArrayOutputStream();
400       System.setOut(new PrintStream(baos));
401 
402       GrouperClient
403           .main(GrouperClientUtils
404               .splitTrim(
405                   "--operation=addMemberWs --groupName=aStem:aGroup --pennIds=test.subject.0 --disabledTime=2010/02/03",
406                   " "));
407       System.out.flush();
408       output = new String(baos.toByteArray());
409 
410       System.setOut(systemOut);
411 
412       outputLines = GrouperClientUtils.splitTrim(output, "\n");
413 
414       matcher = pattern.matcher(outputLines[0]);
415 
416       assertTrue(outputLines[0], matcher.matches());
417 
418       assertEquals("0", matcher.group(1));
419       assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
420       assertEquals("test.subject.0", matcher.group(3));
421 
422       membership = group.getImmediateMembership(Group.getDefaultList(), SubjectTestHelper.SUBJ0, false, true);
423       assertEquals(GrouperClientUtils.stringToDate("2010/02/03 00:00:00.000"), membership.getDisabledTime());
424       assertEquals(null, membership.getEnabledTime());
425 
426       // #####################################################
427       // run again, remove enabled disabled
428       baos = new ByteArrayOutputStream();
429       System.setOut(new PrintStream(baos));
430 
431       GrouperClient
432           .main(GrouperClientUtils
433               .splitTrim(
434                   "--operation=addMemberWs --groupName=aStem:aGroup --pennIds=test.subject.0",
435                   " "));
436       System.out.flush();
437       output = new String(baos.toByteArray());
438 
439       System.setOut(systemOut);
440 
441       outputLines = GrouperClientUtils.splitTrim(output, "\n");
442 
443       matcher = pattern.matcher(outputLines[0]);
444 
445       assertTrue(outputLines[0], matcher.matches());
446 
447       assertEquals("0", matcher.group(1));
448       assertEquals("SUCCESS", matcher.group(2));
449       assertEquals("test.subject.0", matcher.group(3));
450 
451       membership = group.getImmediateMembership(Group.getDefaultList(), SubjectTestHelper.SUBJ0, false, true);
452       assertEquals(null, membership.getDisabledTime());
453       assertEquals(null, membership.getEnabledTime());
454 
455       // #####################################################
456       // run again, with uuid
457       baos = new ByteArrayOutputStream();
458       System.setOut(new PrintStream(baos));
459 
460       GrouperClient
461           .main(GrouperClientUtils
462               .splitTrim(
463                   "--operation=addMemberWs --groupUuid=" + group.getUuid() + " --pennIds=test.subject.0,test.subject.1",
464                   " "));
465       System.out.flush();
466       output = new String(baos.toByteArray());
467 
468       System.setOut(systemOut);
469 
470       outputLines = GrouperClientUtils.splitTrim(output, "\n");
471 
472       matcher = pattern.matcher(outputLines[0]);
473 
474       assertTrue(outputLines[0], matcher.matches());
475 
476       assertEquals("0", matcher.group(1));
477       assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
478       assertEquals("test.subject.0", matcher.group(3));
479 
480       matcher = pattern.matcher(outputLines[1]);
481 
482       assertTrue(outputLines[1], matcher.matches());
483 
484       assertEquals("1", matcher.group(1));
485       assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
486       assertEquals("test.subject.1", matcher.group(3));
487 
488       // #####################################################
489       // run again, with idIndex
490       baos = new ByteArrayOutputStream();
491       System.setOut(new PrintStream(baos));
492 
493       GrouperClient
494           .main(GrouperClientUtils
495               .splitTrim(
496                   "--operation=addMemberWs --groupIdIndex=" + group.getIdIndex() + " --pennIds=test.subject.0,test.subject.1",
497                   " "));
498       System.out.flush();
499       output = new String(baos.toByteArray());
500 
501       System.setOut(systemOut);
502 
503       outputLines = GrouperClientUtils.splitTrim(output, "\n");
504 
505       matcher = pattern.matcher(outputLines[0]);
506 
507       assertTrue(outputLines[0], matcher.matches());
508 
509       assertEquals("0", matcher.group(1));
510       assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
511       assertEquals("test.subject.0", matcher.group(3));
512 
513       matcher = pattern.matcher(outputLines[1]);
514 
515       assertTrue(outputLines[1], matcher.matches());
516 
517       assertEquals("1", matcher.group(1));
518       assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
519       assertEquals("test.subject.1", matcher.group(3));
520 
521       // #####################################################
522       // run with invalid args
523       baos = new ByteArrayOutputStream();
524       System.setOut(new PrintStream(baos));
525 
526       // test a command line template
527       try {
528         GrouperClient
529             .main(GrouperClientUtils
530                 .splitTrim(
531                     "--operation=addMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --ousdfsdfate=${index}",
532                     " "));
533       } catch (Exception e) {
534         assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
535       }
536       System.out.flush();
537 
538       System.setOut(systemOut);
539 
540       // #####################################################
541       // run with custom template
542       baos = new ByteArrayOutputStream();
543       System.setOut(new PrintStream(baos));
544 
545       // test a command line template
546       GrouperClient
547           .main(GrouperClientUtils
548               .splitTrim(
549                   "--operation=addMemberWs --groupName=aStem:aGroup --subjectIdentifiers=id.test.subject.0,id.test.subject.1 --outputTemplate=${index}",
550                   " "));
551 
552       System.out.flush();
553 
554       output = new String(baos.toByteArray());
555 
556       System.setOut(systemOut);
557 
558       assertEquals("01", output);
559 
560       // #####################################################
561       // run again, with field
562       baos = new ByteArrayOutputStream();
563       System.setOut(new PrintStream(baos));
564 
565       GrouperClient
566           .main(GrouperClientUtils
567               .splitTrim(
568                   "--operation=addMemberWs --groupName=aStem:aGroup --pennKeys=id.test.subject.0,id.test.subject.1 --fieldName=members",
569                   " "));
570       System.out.flush();
571       output = new String(baos.toByteArray());
572 
573       System.setOut(systemOut);
574 
575       outputLines = GrouperClientUtils.splitTrim(output, "\n");
576 
577       matcher = pattern.matcher(outputLines[0]);
578 
579       assertTrue(outputLines[0], matcher.matches());
580 
581       assertEquals("0", matcher.group(1));
582       assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
583       assertEquals("test.subject.0", matcher.group(3));
584 
585       matcher = pattern.matcher(outputLines[1]);
586 
587       assertTrue(outputLines[1], matcher.matches());
588 
589       assertEquals("1", matcher.group(1));
590       assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
591       assertEquals("test.subject.1", matcher.group(3));
592 
593       assertTrue(GrouperClientWs.mostRecentRequest,
594           GrouperClientWs.mostRecentRequest.contains("fieldName")
595               && GrouperClientWs.mostRecentRequest.contains("members")
596               && !GrouperClientWs.mostRecentRequest.contains("txType"));
597 
598       // #####################################################
599       // run again, with txType
600       baos = new ByteArrayOutputStream();
601       System.setOut(new PrintStream(baos));
602 
603       GrouperClient
604           .main(GrouperClientUtils
605               .splitTrim(
606                   "--operation=addMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --txType=NONE",
607                   " "));
608       System.out.flush();
609       output = new String(baos.toByteArray());
610 
611       System.setOut(systemOut);
612 
613       outputLines = GrouperClientUtils.splitTrim(output, "\n");
614 
615       matcher = pattern.matcher(outputLines[0]);
616 
617       assertTrue(outputLines[0], matcher.matches());
618 
619       assertEquals("0", matcher.group(1));
620       assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
621       assertEquals("test.subject.0", matcher.group(3));
622 
623       matcher = pattern.matcher(outputLines[1]);
624 
625       assertTrue(outputLines[1], matcher.matches());
626 
627       assertEquals("1", matcher.group(1));
628       assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
629       assertEquals("test.subject.1", matcher.group(3));
630 
631       assertTrue(GrouperClientWs.mostRecentRequest,
632           !GrouperClientWs.mostRecentRequest.contains("fieldName")
633               && !GrouperClientWs.mostRecentRequest.contains("members")
634               && GrouperClientWs.mostRecentRequest.contains("txType")
635               && GrouperClientWs.mostRecentRequest.contains("NONE")
636               && !GrouperClientWs.mostRecentRequest
637                   .contains("includeGroupDetail")
638               && !GrouperClientWs.mostRecentRequest
639                   .contains("includeSubjectDetail")
640               && !GrouperClientWs.mostRecentRequest
641                   .contains("includeGroupDetail")
642               && !GrouperClientWs.mostRecentRequest
643                   .contains("includeSubjectDetail"));
644 
645       // #####################################################
646       // run again, with includeGroupDetail and includeSubjectDetail
647       baos = new ByteArrayOutputStream();
648       System.setOut(new PrintStream(baos));
649 
650       GrouperClient
651           .main(GrouperClientUtils
652               .splitTrim(
653                   "--operation=addMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --includeGroupDetail=true --includeSubjectDetail=true",
654                   " "));
655       System.out.flush();
656       output = new String(baos.toByteArray());
657 
658       System.setOut(systemOut);
659 
660       outputLines = GrouperClientUtils.splitTrim(output, "\n");
661 
662       matcher = pattern.matcher(outputLines[0]);
663 
664       assertTrue(outputLines[0], matcher.matches());
665 
666       assertEquals("0", matcher.group(1));
667       assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
668       assertEquals("test.subject.0", matcher.group(3));
669 
670       matcher = pattern.matcher(outputLines[1]);
671 
672       assertTrue(outputLines[1], matcher.matches());
673 
674       assertEquals("1", matcher.group(1));
675       assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
676       assertEquals("test.subject.1", matcher.group(3));
677 
678       assertTrue(!GrouperClientWs.mostRecentRequest.contains("txType")
679           && !GrouperClientWs.mostRecentRequest.contains("NONE")
680           && GrouperClientWs.mostRecentRequest.contains("includeGroupDetail")
681           && GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
682 
683       // #####################################################
684       // run again, with subject attributes
685       baos = new ByteArrayOutputStream();
686       System.setOut(new PrintStream(baos));
687 
688       GrouperClient
689           .main(GrouperClientUtils
690               .splitTrim(
691                   "--operation=addMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --subjectAttributeNames=name --outputTemplate=${index}:$space$${wsAddMemberResult.wsSubject.getAttributeValue(0)}$newline$",
692                   " "));
693       System.out.flush();
694       output = new String(baos.toByteArray());
695 
696       System.setOut(systemOut);
697 
698       outputLines = GrouperClientUtils.splitTrim(output, "\n");
699 
700       assertTrue(outputLines[0], outputLines[0]
701           .contains("my name is test.subject.0"));
702 
703       assertTrue(outputLines[1], outputLines[1]
704           .contains("my name is test.subject.1"));
705 
706       assertTrue(GrouperClientWs.mostRecentRequest.contains(">name<"));
707       assertTrue(GrouperClientWs.mostRecentResponse
708           .contains("my name is test.subject.0"));
709 
710       // #####################################################
711       // run again, with default subject source
712       baos = new ByteArrayOutputStream();
713       System.setOut(new PrintStream(baos));
714 
715       GrouperClient
716           .main(GrouperClientUtils
717               .splitTrim(
718                   "--operation=addMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --defaultSubjectSource=jdbc",
719                   " "));
720       System.out.flush();
721       output = new String(baos.toByteArray());
722 
723       System.setOut(systemOut);
724 
725       outputLines = GrouperClientUtils.splitTrim(output, "\n");
726 
727       matcher = pattern.matcher(outputLines[0]);
728 
729       assertTrue(outputLines[0], matcher.matches());
730 
731       assertEquals("0", matcher.group(1));
732       assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
733       assertEquals("test.subject.0", matcher.group(3));
734 
735       matcher = pattern.matcher(outputLines[1]);
736 
737       assertTrue(outputLines[1], matcher.matches());
738 
739       assertEquals("1", matcher.group(1));
740       assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
741       assertEquals("test.subject.1", matcher.group(3));
742 
743       assertTrue(GrouperClientWs.mostRecentRequest.contains("jdbc"));
744 
745       // #####################################################
746       // run again, subjects ids coming from file
747       baos = new ByteArrayOutputStream();
748       System.setOut(new PrintStream(baos));
749 
750       String subjectIdsFileName = "subjectIdsFile_"
751           + GrouperClientUtils.uniqueId() + ".txt";
752       File subjectIdsFile = new File(subjectIdsFileName);
753 
754       GrouperClientUtils.saveStringIntoFile(subjectIdsFile,
755           "test.subject.0\ntest.subject.1");
756 
757       try {
758         GrouperClient.main(GrouperClientUtils.splitTrim(
759             "--operation=addMemberWs --groupName=aStem:aGroup --subjectIdsFile="
760                 + subjectIdsFileName, " "));
761         System.out.flush();
762         output = new String(baos.toByteArray());
763 
764         System.setOut(systemOut);
765 
766         outputLines = GrouperClientUtils.splitTrim(output, "\n");
767 
768         matcher = pattern.matcher(outputLines[0]);
769 
770         assertTrue(outputLines[0], matcher.matches());
771 
772         assertEquals("0", matcher.group(1));
773         assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
774         assertEquals("test.subject.0", matcher.group(3));
775 
776         matcher = pattern.matcher(outputLines[1]);
777 
778         assertTrue(outputLines[1], matcher.matches());
779 
780         assertEquals("1", matcher.group(1));
781         assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
782         assertEquals("test.subject.1", matcher.group(3));
783 
784         // #####################################################
785         // run again, with params
786         baos = new ByteArrayOutputStream();
787         System.setOut(new PrintStream(baos));
788 
789         GrouperClient
790             .main(GrouperClientUtils
791                 .splitTrim(
792                     "--operation=addMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --paramName0=whatever --paramValue0=someValue",
793                     " "));
794         System.out.flush();
795         output = new String(baos.toByteArray());
796 
797         System.setOut(systemOut);
798 
799         outputLines = GrouperClientUtils.splitTrim(output, "\n");
800 
801         matcher = pattern.matcher(outputLines[0]);
802 
803         assertTrue(outputLines[0], matcher.matches());
804 
805         assertEquals("0", matcher.group(1));
806         assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
807         assertEquals("test.subject.0", matcher.group(3));
808 
809         matcher = pattern.matcher(outputLines[1]);
810 
811         assertTrue(outputLines[1], matcher.matches());
812 
813         assertEquals("1", matcher.group(1));
814         assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
815         assertEquals("test.subject.1", matcher.group(3));
816 
817         assertTrue(GrouperClientWs.mostRecentRequest.contains("whatever")
818             && GrouperClientWs.mostRecentRequest.contains("someValue"));
819 
820         // #####################################################
821         // run again, with addExternalSubjectIfNotFound
822         baos = new ByteArrayOutputStream();
823         System.setOut(new PrintStream(baos));
824 
825         //NOTE FOR THIS TO WORK YOU NEED TO ENABLE (externalSubjects.autoCreateSource = true) AUTO CREATE EXTERNAL SUBJECTS IN GROUPER.PROPERTIES ON WS
826         GrouperClient
827             .main(GrouperClientUtils
828                 .splitTrim(
829                     "--operation=addMemberWs --groupName=aStem:aGroup --subjectIdentifiers=a@b.c --addExternalSubjectIfNotFound=true",
830                     " "));
831         System.out.flush();
832         output = new String(baos.toByteArray());
833 
834         System.setOut(systemOut);
835 
836         outputLines = GrouperClientUtils.splitTrim(output, "\n");
837         assertEquals(1, outputLines.length);
838 
839         matcher = pattern.matcher(outputLines[0]);
840 
841         assertTrue(outputLines[0], matcher.matches());
842 
843         assertEquals("0", matcher.group(1));
844         assertEquals("SUCCESS_CREATED", matcher.group(2));
845         //cant do that since not the id... its the identifier
846         //assertEquals("a@b.c", matcher.group(3));
847 
848         assertTrue(GrouperClientWs.mostRecentRequest
849             .contains("addExternalSubjectIfNotFound"));
850 
851         // #####################################################
852         // run again, with replaceAllExisting
853         baos = new ByteArrayOutputStream();
854         System.setOut(new PrintStream(baos));
855 
856         GrouperClient
857             .main(GrouperClientUtils
858                 .splitTrim(
859                     "--operation=addMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --replaceAllExisting=true",
860                     " "));
861         System.out.flush();
862         output = new String(baos.toByteArray());
863 
864         System.setOut(systemOut);
865 
866         outputLines = GrouperClientUtils.splitTrim(output, "\n");
867 
868         matcher = pattern.matcher(outputLines[0]);
869 
870         assertTrue(outputLines[0], matcher.matches());
871 
872         assertEquals("0", matcher.group(1));
873         assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
874         assertEquals("test.subject.0", matcher.group(3));
875 
876         matcher = pattern.matcher(outputLines[1]);
877 
878         assertTrue(outputLines[1], matcher.matches());
879 
880         assertEquals("1", matcher.group(1));
881         assertEquals("SUCCESS_ALREADY_EXISTED", matcher.group(2));
882         assertEquals("test.subject.1", matcher.group(3));
883 
884         assertTrue(GrouperClientWs.mostRecentRequest
885             .contains("replaceAllExisting"));
886 
887         // #######################################################
888         // get members, make sure all there
889 
890         baos = new ByteArrayOutputStream();
891         System.setOut(new PrintStream(baos));
892 
893         GrouperClient
894             .main(GrouperClientUtils
895                 .splitTrim(
896                     "--operation=hasMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1",
897                     " "));
898         System.out.flush();
899         output = new String(baos.toByteArray());
900 
901         System.setOut(systemOut);
902 
903         outputLines = GrouperClientUtils.splitTrim(output, "\n");
904 
905         pattern = Pattern
906             .compile("^Index (\\d+): success: T: code: ([A-Z_]+): (.+): (false|true)$");
907         matcher = pattern.matcher(outputLines[0]);
908 
909         assertTrue(outputLines[0], matcher.matches());
910 
911         assertEquals("0", matcher.group(1));
912         assertEquals("IS_MEMBER", matcher.group(2));
913         assertEquals("test.subject.0", matcher.group(3));
914         assertEquals("true", matcher.group(4));
915 
916         matcher = pattern.matcher(outputLines[1]);
917 
918         assertTrue(outputLines[1], matcher.matches());
919 
920         assertEquals("1", matcher.group(1));
921         assertEquals("IS_MEMBER", matcher.group(2));
922         assertEquals("test.subject.1", matcher.group(3));
923         assertEquals("true", matcher.group(4));
924 
925       } finally {
926         if (subjectIdsFile.exists()) {
927           subjectIdsFile.delete();
928         }
929       }
930     } finally {
931       System.setOut(systemOut);
932     }
933 
934   }
935 
936   /**
937    * @throws Exception
938    */
939   public void testGetGrouperPrivilegeLite() throws Exception {
940 
941     PrintStream systemOut = System.out;
942 
943     ByteArrayOutputStream baos = new ByteArrayOutputStream();
944     System.setOut(new PrintStream(baos));
945 
946     try {
947 
948       GrouperClient
949           .main(GrouperClientUtils
950               .splitTrim(
951                   "--operation=getGrouperPrivilegesLiteWs --groupName=aStem:aGroup --subjectId=test.subject.0",
952                   " "));
953       System.out.flush();
954       String output = new String(baos.toByteArray());
955 
956       System.setOut(systemOut);
957 
958       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
959 
960       Pattern pattern = Pattern
961           .compile("^Index (\\d+): success: T: code: ([A-Z_]+): (group|stem): (.+): subject: (.+): (.+): (.+)$");
962       Matcher matcher = pattern.matcher(outputLines[0]);
963 
964       assertEquals(GrouperClientUtils.length(outputLines), 3);
965       assertTrue(outputLines[0], matcher.matches());
966 
967       assertEquals("0", matcher.group(1));
968       assertEquals("SUCCESS", matcher.group(2));
969       assertEquals("group", matcher.group(3));
970       assertEquals("aStem:aGroup", matcher.group(4));
971       assertEquals("test.subject.0", matcher.group(5));
972       assertEquals("access", matcher.group(6));
973       assertEquals("admin", matcher.group(7));
974 
975       matcher = pattern.matcher(outputLines[1]);
976 
977       assertTrue(outputLines[1], matcher.matches());
978 
979       assertEquals("1", matcher.group(1));
980       assertEquals("SUCCESS", matcher.group(2));
981       assertEquals("group", matcher.group(3));
982       assertEquals("aStem:aGroup", matcher.group(4));
983       assertEquals("test.subject.0", matcher.group(5));
984       assertEquals("access", matcher.group(6));
985       assertEquals("read", matcher.group(7));
986 
987       matcher = pattern.matcher(outputLines[2]);
988 
989       assertTrue(outputLines[2], matcher.matches());
990 
991       assertEquals("2", matcher.group(1));
992       assertEquals("SUCCESS", matcher.group(2));
993       assertEquals("group", matcher.group(3));
994       assertEquals("aStem:aGroup", matcher.group(4));
995       assertEquals("test.subject.0", matcher.group(5));
996       assertEquals("access", matcher.group(6));
997       assertEquals("view", matcher.group(7));
998 
999       // #####################################################
1000       // run again with subject identifier, and privilege type
1001       baos = new ByteArrayOutputStream();
1002       System.setOut(new PrintStream(baos));
1003 
1004       GrouperClient
1005           .main(GrouperClientUtils
1006               .splitTrim(
1007                   "--operation=getGrouperPrivilegesLiteWs --groupName=aStem:aGroup --subjectIdentifier=id.test.subject.0 --privilegeType=access",
1008                   " "));
1009       System.out.flush();
1010       output = new String(baos.toByteArray());
1011 
1012       System.setOut(systemOut);
1013 
1014       outputLines = GrouperClientUtils.splitTrim(output, "\n");
1015 
1016       matcher = pattern.matcher(outputLines[0]);
1017 
1018       assertEquals(GrouperClientUtils.length(outputLines), 3);
1019       assertTrue(outputLines[0], matcher.matches());
1020 
1021       assertEquals("0", matcher.group(1));
1022       assertEquals("SUCCESS", matcher.group(2));
1023       assertEquals("group", matcher.group(3));
1024       assertEquals("aStem:aGroup", matcher.group(4));
1025       assertEquals("test.subject.0", matcher.group(5));
1026       assertEquals("access", matcher.group(6));
1027       assertEquals("admin", matcher.group(7));
1028 
1029       matcher = pattern.matcher(outputLines[1]);
1030 
1031       assertTrue(outputLines[1], matcher.matches());
1032 
1033       assertEquals("1", matcher.group(1));
1034       assertEquals("SUCCESS", matcher.group(2));
1035       assertEquals("group", matcher.group(3));
1036       assertEquals("aStem:aGroup", matcher.group(4));
1037       assertEquals("test.subject.0", matcher.group(5));
1038       assertEquals("access", matcher.group(6));
1039       assertEquals("read", matcher.group(7));
1040 
1041       matcher = pattern.matcher(outputLines[2]);
1042 
1043       assertTrue(outputLines[2], matcher.matches());
1044 
1045       assertEquals("2", matcher.group(1));
1046       assertEquals("SUCCESS", matcher.group(2));
1047       assertEquals("group", matcher.group(3));
1048       assertEquals("aStem:aGroup", matcher.group(4));
1049       assertEquals("test.subject.0", matcher.group(5));
1050       assertEquals("access", matcher.group(6));
1051       assertEquals("view", matcher.group(7));
1052 
1053       assertTrue(GrouperClientWs.mostRecentRequest,
1054           GrouperClientWs.mostRecentRequest.contains("access")
1055               && GrouperClientWs.mostRecentRequest.contains("privilegeType")
1056               && GrouperClientWs.mostRecentRequest
1057                   .contains("id.test.subject.0"));
1058 
1059       // #####################################################
1060       // run with invalid args
1061       baos = new ByteArrayOutputStream();
1062       System.setOut(new PrintStream(baos));
1063 
1064       // test a command line template
1065       try {
1066         GrouperClient
1067             .main(GrouperClientUtils
1068                 .splitTrim(
1069                     "--operation=getGrouperPrivilegesLiteWs --groupName=aStem:aGroup --subjectId=test.subject.0 --ousdfsdfate=${index}",
1070                     " "));
1071       } catch (Exception e) {
1072         assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
1073       }
1074       System.out.flush();
1075 
1076       System.setOut(systemOut);
1077 
1078       // #####################################################
1079       // run with custom template
1080       baos = new ByteArrayOutputStream();
1081       System.setOut(new PrintStream(baos));
1082 
1083       // test a command line template
1084       GrouperClient
1085           .main(GrouperClientUtils
1086               .splitTrim(
1087                   "--operation=getGrouperPrivilegesLiteWs --groupName=aStem:aGroup --pennKey=id.test.subject.0 --outputTemplate=${index}",
1088                   " "));
1089 
1090       System.out.flush();
1091 
1092       output = new String(baos.toByteArray());
1093 
1094       assertEquals("012", output);
1095 
1096       System.setOut(systemOut);
1097 
1098       // #####################################################
1099       // run with privilege name
1100       baos = new ByteArrayOutputStream();
1101       System.setOut(new PrintStream(baos));
1102 
1103       // test a command line template
1104       GrouperClient
1105           .main(GrouperClientUtils
1106               .splitTrim(
1107                   "--operation=getGrouperPrivilegesLiteWs --groupName=aStem:aGroup --pennKey=id.test.subject.0 --privilegeName=admin",
1108                   " "));
1109 
1110       System.out.flush();
1111 
1112       output = new String(baos.toByteArray());
1113 
1114       System.setOut(systemOut);
1115 
1116       outputLines = GrouperClientUtils.splitTrim(output, "\n");
1117 
1118       matcher = pattern.matcher(outputLines[0]);
1119 
1120       assertEquals(output, GrouperClientUtils.length(outputLines), 1);
1121       assertTrue(outputLines[0], matcher.matches());
1122 
1123       assertEquals("0", matcher.group(1));
1124       assertEquals(outputLines[0], "SUCCESS_ALLOWED", matcher.group(2));
1125       assertEquals("group", matcher.group(3));
1126       assertEquals("aStem:aGroup", matcher.group(4));
1127       assertEquals("test.subject.0", matcher.group(5));
1128       assertEquals("access", matcher.group(6));
1129       assertEquals("admin", matcher.group(7));
1130 
1131       assertTrue(GrouperClientWs.mostRecentRequest,
1132           GrouperClientWs.mostRecentRequest.contains("admin")
1133               && GrouperClientWs.mostRecentRequest.contains("privilegeName")
1134               && GrouperClientWs.mostRecentRequest
1135                   .contains("id.test.subject.0"));
1136 
1137       // #####################################################
1138       // run again, with stem
1139       baos = new ByteArrayOutputStream();
1140       System.setOut(new PrintStream(baos));
1141 
1142       GrouperClient
1143           .main(GrouperClientUtils
1144               .splitTrim(
1145                   "--operation=getGrouperPrivilegesLiteWs --stemName=aStem --pennKey=id.test.subject.0",
1146                   " "));
1147       System.out.flush();
1148       output = new String(baos.toByteArray());
1149 
1150       System.setOut(systemOut);
1151 
1152       outputLines = GrouperClientUtils.splitTrim(output, "\n");
1153 
1154       matcher = pattern.matcher(outputLines[0]);
1155 
1156       assertEquals(GrouperClientUtils.length(outputLines), 2);
1157       assertTrue(outputLines[0], matcher.matches());
1158 
1159       // #####################################################
1160       // run again, with stem with no results
1161       baos = new ByteArrayOutputStream();
1162       System.setOut(new PrintStream(baos));
1163 
1164       GrouperClient
1165           .main(GrouperClientUtils
1166               .splitTrim(
1167                   "--operation=getGrouperPrivilegesLiteWs --stemName=aStem --pennKey=id.test.subject.6",
1168                   " "));
1169       System.out.flush();
1170       output = new String(baos.toByteArray());
1171 
1172       System.setOut(systemOut);
1173 
1174       assertTrue(outputLines[0], StringUtils.isBlank(output));
1175 
1176       // Index 0: success: T: code: SUCCESS: stem: aStem: subject:
1177       // test.subject.0: naming: create
1178       // Index 1: success: T: code: SUCCESS: stem: aStem: subject:
1179       // test.subject.0: naming: stemAdmin
1180 
1181       assertEquals("0", matcher.group(1));
1182       assertEquals("SUCCESS", matcher.group(2));
1183       assertEquals("stem", matcher.group(3));
1184       assertEquals("aStem", matcher.group(4));
1185       assertEquals("test.subject.0", matcher.group(5));
1186       assertEquals("naming", matcher.group(6));
1187       assertEquals("create", matcher.group(7));
1188 
1189       matcher = pattern.matcher(outputLines[1]);
1190 
1191       assertTrue(outputLines[1], matcher.matches());
1192 
1193       assertEquals("1", matcher.group(1));
1194       assertEquals("SUCCESS", matcher.group(2));
1195       assertEquals("stem", matcher.group(3));
1196       assertEquals("aStem", matcher.group(4));
1197       assertEquals("test.subject.0", matcher.group(5));
1198       assertEquals("naming", matcher.group(6));
1199       assertEquals("stemAdmin", matcher.group(7));
1200 
1201       // #####################################################
1202       // run again, with includeGroupDetail and includeSubjectDetail
1203       baos = new ByteArrayOutputStream();
1204       System.setOut(new PrintStream(baos));
1205 
1206       GrouperClient
1207           .main(GrouperClientUtils
1208               .splitTrim(
1209                   "--operation=getGrouperPrivilegesLiteWs --groupName=aStem:aGroup --subjectId=test.subject.0 --includeGroupDetail=true --includeSubjectDetail=true",
1210                   " "));
1211       System.out.flush();
1212       output = new String(baos.toByteArray());
1213 
1214       System.setOut(systemOut);
1215 
1216       outputLines = GrouperClientUtils.splitTrim(output, "\n");
1217 
1218       matcher = pattern.matcher(outputLines[0]);
1219 
1220       assertEquals(3, GrouperClientUtils.length(outputLines));
1221       assertTrue(outputLines[0], matcher.matches());
1222 
1223       assertEquals("0", matcher.group(1));
1224       assertEquals("SUCCESS", matcher.group(2));
1225       assertEquals("group", matcher.group(3));
1226       assertEquals("aStem:aGroup", matcher.group(4));
1227       assertEquals("test.subject.0", matcher.group(5));
1228       assertEquals("access", matcher.group(6));
1229       assertEquals("admin", matcher.group(7));
1230 
1231       matcher = pattern.matcher(outputLines[1]);
1232 
1233       assertTrue(outputLines[1], matcher.matches());
1234 
1235       assertEquals("1", matcher.group(1));
1236       assertEquals("SUCCESS", matcher.group(2));
1237       assertEquals("group", matcher.group(3));
1238       assertEquals("aStem:aGroup", matcher.group(4));
1239       assertEquals("test.subject.0", matcher.group(5));
1240       assertEquals("access", matcher.group(6));
1241       assertEquals("read", matcher.group(7));
1242 
1243       matcher = pattern.matcher(outputLines[2]);
1244 
1245       assertTrue(outputLines[2], matcher.matches());
1246 
1247       assertEquals("2", matcher.group(1));
1248       assertEquals("SUCCESS", matcher.group(2));
1249       assertEquals("group", matcher.group(3));
1250       assertEquals("aStem:aGroup", matcher.group(4));
1251       assertEquals("test.subject.0", matcher.group(5));
1252       assertEquals("access", matcher.group(6));
1253       assertEquals("view", matcher.group(7));
1254 
1255       assertTrue(GrouperClientWs.mostRecentRequest
1256           .contains("includeGroupDetail")
1257           && GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
1258 
1259       // #####################################################
1260       // run again, with subject attributes
1261       baos = new ByteArrayOutputStream();
1262       System.setOut(new PrintStream(baos));
1263 
1264       GrouperClient
1265           .main(GrouperClientUtils
1266               .splitTrim(
1267                   "--operation=getGrouperPrivilegesLiteWs --groupName=aStem:aGroup --subjectId=test.subject.0 --subjectAttributeNames=name --outputTemplate=${index}:$space$${wsSubject.getAttributeValue(0)}$newline$",
1268                   " "));
1269       System.out.flush();
1270       output = new String(baos.toByteArray());
1271 
1272       System.setOut(systemOut);
1273 
1274       outputLines = GrouperClientUtils.splitTrim(output, "\n");
1275 
1276       assertTrue(outputLines[0], outputLines[0]
1277           .contains("my name is test.subject.0"));
1278 
1279       assertTrue(outputLines[1], outputLines[1]
1280           .contains("my name is test.subject.0"));
1281 
1282       assertTrue(GrouperClientWs.mostRecentRequest.contains(">name<"));
1283       assertTrue(GrouperClientWs.mostRecentResponse
1284           .contains("my name is test.subject.0"));
1285 
1286       // #####################################################
1287       // run again, with params
1288       baos = new ByteArrayOutputStream();
1289       System.setOut(new PrintStream(baos));
1290 
1291       GrouperClient
1292           .main(GrouperClientUtils
1293               .splitTrim(
1294                   "--operation=getGrouperPrivilegesLiteWs --groupName=aStem:aGroup --subjectId=test.subject.0 --paramName0=whatever --paramValue0=someValue",
1295                   " "));
1296       System.out.flush();
1297       output = new String(baos.toByteArray());
1298 
1299       System.setOut(systemOut);
1300 
1301       outputLines = GrouperClientUtils.splitTrim(output, "\n");
1302 
1303       matcher = pattern.matcher(outputLines[0]);
1304 
1305       assertEquals(GrouperClientUtils.length(outputLines), 3);
1306       assertTrue(outputLines[0], matcher.matches());
1307 
1308       assertEquals("0", matcher.group(1));
1309       assertEquals("SUCCESS", matcher.group(2));
1310       assertEquals("group", matcher.group(3));
1311       assertEquals("aStem:aGroup", matcher.group(4));
1312       assertEquals("test.subject.0", matcher.group(5));
1313       assertEquals("access", matcher.group(6));
1314       assertEquals("admin", matcher.group(7));
1315 
1316       matcher = pattern.matcher(outputLines[1]);
1317 
1318       assertTrue(outputLines[1], matcher.matches());
1319 
1320       assertEquals("1", matcher.group(1));
1321       assertEquals("SUCCESS", matcher.group(2));
1322       assertEquals("group", matcher.group(3));
1323       assertEquals("aStem:aGroup", matcher.group(4));
1324       assertEquals("test.subject.0", matcher.group(5));
1325       assertEquals("access", matcher.group(6));
1326       assertEquals("read", matcher.group(7));
1327 
1328       matcher = pattern.matcher(outputLines[2]);
1329 
1330       assertTrue(outputLines[2], matcher.matches());
1331 
1332       assertEquals("2", matcher.group(1));
1333       assertEquals("SUCCESS", matcher.group(2));
1334       assertEquals("group", matcher.group(3));
1335       assertEquals("aStem:aGroup", matcher.group(4));
1336       assertEquals("test.subject.0", matcher.group(5));
1337       assertEquals("access", matcher.group(6));
1338       assertEquals("view", matcher.group(7));
1339 
1340       assertTrue(GrouperClientWs.mostRecentRequest.contains("whatever")
1341           && GrouperClientWs.mostRecentRequest.contains("someValue"));
1342 
1343     } finally {
1344       System.setOut(systemOut);
1345     }
1346 
1347   }
1348 
1349   /**
1350    * @throws Exception
1351    */
1352   public void testAssignGrouperPrivilegeLite() throws Exception {
1353 
1354     PrintStream systemOut = System.out;
1355 
1356     ByteArrayOutputStream baos = new ByteArrayOutputStream();
1357     System.setOut(new PrintStream(baos));
1358 
1359     try {
1360 
1361       GrouperClient
1362           .main(GrouperClientUtils
1363               .splitTrim(
1364                   "--operation=assignGrouperPrivilegesLiteWs --groupName=aStem:aGroup --subjectId=test.subject.0 --privilegeName=optin --allowed=true",
1365                   " "));
1366       System.out.flush();
1367       String output = new String(baos.toByteArray());
1368 
1369       System.setOut(systemOut);
1370 
1371       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
1372 
1373       Pattern pattern = Pattern
1374           .compile("^Success: T: code: ([A-Z_]+): (group|stem): (.+): subject: (.+): (.+): (.+)$");
1375       Matcher matcher = pattern.matcher(outputLines[0]);
1376 
1377       assertEquals(GrouperClientUtils.length(outputLines), 1);
1378       assertTrue(outputLines[0], matcher.matches());
1379 
1380       assertEquals("SUCCESS_ALLOWED", matcher.group(1));
1381       assertEquals("group", matcher.group(2));
1382       assertEquals("aStem:aGroup", matcher.group(3));
1383       assertEquals("test.subject.0", matcher.group(4));
1384       assertEquals("access", matcher.group(5));
1385       assertEquals("optin", matcher.group(6));
1386 
1387       // #####################################################
1388       // run again with subject identifier, and privilege type
1389       baos = new ByteArrayOutputStream();
1390       System.setOut(new PrintStream(baos));
1391 
1392       GrouperClient
1393           .main(GrouperClientUtils
1394               .splitTrim(
1395                   "--operation=assignGrouperPrivilegesLiteWs --groupName=aStem:aGroup --subjectIdentifier=id.test.subject.0 --privilegeType=access --privilegeName=optin --allowed=true",
1396                   " "));
1397       System.out.flush();
1398       output = new String(baos.toByteArray());
1399 
1400       System.setOut(systemOut);
1401 
1402       outputLines = GrouperClientUtils.splitTrim(output, "\n");
1403 
1404       matcher = pattern.matcher(outputLines[0]);
1405 
1406       assertEquals(GrouperClientUtils.length(outputLines), 1);
1407       assertTrue(outputLines[0], matcher.matches());
1408 
1409       assertEquals("SUCCESS_ALLOWED_ALREADY_EXISTED", matcher.group(1));
1410       assertEquals("group", matcher.group(2));
1411       assertEquals("aStem:aGroup", matcher.group(3));
1412       assertEquals("test.subject.0", matcher.group(4));
1413       assertEquals("access", matcher.group(5));
1414       assertEquals("optin", matcher.group(6));
1415 
1416       assertTrue(GrouperClientWs.mostRecentRequest,
1417           GrouperClientWs.mostRecentRequest.contains("access")
1418               && GrouperClientWs.mostRecentRequest.contains("privilegeType")
1419               && GrouperClientWs.mostRecentRequest
1420                   .contains("id.test.subject.0"));
1421 
1422       // #####################################################
1423       // run with invalid args
1424       baos = new ByteArrayOutputStream();
1425       System.setOut(new PrintStream(baos));
1426 
1427       // test a command line template
1428       try {
1429         GrouperClient
1430             .main(GrouperClientUtils
1431                 .splitTrim(
1432                     "--operation=assignGrouperPrivilegesLiteWs --groupName=aStem:aGroup --subjectId=test.subject.0 --privilegeName=optin --allowed=true --ousdfsdfate=${index}",
1433                     " "));
1434       } catch (Exception e) {
1435         assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
1436       }
1437       System.out.flush();
1438 
1439       System.setOut(systemOut);
1440 
1441       // #####################################################
1442       // run with custom template
1443       baos = new ByteArrayOutputStream();
1444       System.setOut(new PrintStream(baos));
1445 
1446       // test a command line template
1447       GrouperClient
1448           .main(GrouperClientUtils
1449               .splitTrim(
1450                   "--operation=assignGrouperPrivilegesLiteWs --groupName=aStem:aGroup --pennKey=id.test.subject.0 --privilegeName=optin --allowed=true --outputTemplate=${wsSubject.identifierLookup}",
1451                   " "));
1452 
1453       System.out.flush();
1454 
1455       output = new String(baos.toByteArray());
1456 
1457       assertEquals("id.test.subject.0", output);
1458 
1459       System.setOut(systemOut);
1460 
1461       // #####################################################
1462       // run again, with stem
1463       baos = new ByteArrayOutputStream();
1464       System.setOut(new PrintStream(baos));
1465 
1466       GrouperClient
1467           .main(GrouperClientUtils
1468               .splitTrim(
1469                   "--operation=assignGrouperPrivilegesLiteWs --stemName=aStem --pennKey=id.test.subject.0 --privilegeName=stem --allowed=true",
1470                   " "));
1471       System.out.flush();
1472       output = new String(baos.toByteArray());
1473 
1474       System.setOut(systemOut);
1475 
1476       outputLines = GrouperClientUtils.splitTrim(output, "\n");
1477 
1478       matcher = pattern.matcher(outputLines[0]);
1479 
1480       assertEquals(GrouperClientUtils.length(outputLines), 1);
1481       assertTrue(outputLines[0], matcher.matches());
1482 
1483       assertEquals("SUCCESS_ALLOWED_ALREADY_EXISTED", matcher.group(1));
1484       assertEquals("stem", matcher.group(2));
1485       assertEquals("aStem", matcher.group(3));
1486       assertEquals("test.subject.0", matcher.group(4));
1487       assertEquals("naming", matcher.group(5));
1488       assertEquals("stemAdmin", matcher.group(6));
1489 
1490       // #####################################################
1491       // run again, with includeGroupDetail and includeSubjectDetail
1492       baos = new ByteArrayOutputStream();
1493       System.setOut(new PrintStream(baos));
1494 
1495       GrouperClient
1496           .main(GrouperClientUtils
1497               .splitTrim(
1498                   "--operation=assignGrouperPrivilegesLiteWs --groupName=aStem:aGroup --subjectId=test.subject.0 --includeGroupDetail=true --includeSubjectDetail=true --privilegeName=optin --allowed=false",
1499                   " "));
1500       System.out.flush();
1501       output = new String(baos.toByteArray());
1502 
1503       System.setOut(systemOut);
1504 
1505       outputLines = GrouperClientUtils.splitTrim(output, "\n");
1506 
1507       matcher = pattern.matcher(outputLines[0]);
1508 
1509       assertEquals(GrouperClientUtils.length(outputLines), 1);
1510       assertTrue(outputLines[0], matcher.matches());
1511 
1512       assertEquals("SUCCESS_NOT_ALLOWED", matcher.group(1));
1513       assertEquals("group", matcher.group(2));
1514       assertEquals("aStem:aGroup", matcher.group(3));
1515       assertEquals("test.subject.0", matcher.group(4));
1516       assertEquals("access", matcher.group(5));
1517       assertEquals("optin", matcher.group(6));
1518 
1519       assertTrue(GrouperClientWs.mostRecentRequest
1520           .contains("includeGroupDetail")
1521           && GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
1522 
1523       // #####################################################
1524       // run again, with subject attributes
1525       baos = new ByteArrayOutputStream();
1526       System.setOut(new PrintStream(baos));
1527 
1528       GrouperClient
1529           .main(GrouperClientUtils
1530               .splitTrim(
1531                   "--operation=assignGrouperPrivilegesLiteWs --groupName=aStem:aGroup --subjectId=test.subject.0 --subjectAttributeNames=name --privilegeName=optin --allowed=false --outputTemplate=${index}:$space$${wsSubject.getAttributeValue(0)}$newline$",
1532                   " "));
1533       System.out.flush();
1534       output = new String(baos.toByteArray());
1535 
1536       System.setOut(systemOut);
1537 
1538       outputLines = GrouperClientUtils.splitTrim(output, "\n");
1539 
1540       assertTrue(outputLines[0], outputLines[0]
1541           .contains("my name is test.subject.0"));
1542 
1543       assertTrue(GrouperClientWs.mostRecentRequest.contains(">name<"));
1544       assertTrue(GrouperClientWs.mostRecentResponse
1545           .contains("my name is test.subject.0"));
1546 
1547       // #####################################################
1548       // run again, with params
1549       baos = new ByteArrayOutputStream();
1550       System.setOut(new PrintStream(baos));
1551 
1552       GrouperClient
1553           .main(GrouperClientUtils
1554               .splitTrim(
1555                   "--operation=assignGrouperPrivilegesLiteWs --groupName=aStem:aGroup --privilegeName=optin --allowed=false --subjectId=test.subject.0 --paramName0=whatever --paramValue0=someValue",
1556                   " "));
1557       System.out.flush();
1558       output = new String(baos.toByteArray());
1559 
1560       System.setOut(systemOut);
1561 
1562       outputLines = GrouperClientUtils.splitTrim(output, "\n");
1563 
1564       matcher = pattern.matcher(outputLines[0]);
1565 
1566       assertEquals(GrouperClientUtils.length(outputLines), 1);
1567       assertTrue(outputLines[0], matcher.matches());
1568 
1569       assertEquals("SUCCESS_NOT_ALLOWED_DIDNT_EXIST", matcher.group(1));
1570       assertEquals("group", matcher.group(2));
1571       assertEquals("aStem:aGroup", matcher.group(3));
1572       assertEquals("test.subject.0", matcher.group(4));
1573       assertEquals("access", matcher.group(5));
1574       assertEquals("optin", matcher.group(6));
1575 
1576       assertTrue(GrouperClientWs.mostRecentRequest.contains("whatever")
1577           && GrouperClientWs.mostRecentRequest.contains("someValue"));
1578 
1579     } finally {
1580       System.setOut(systemOut);
1581     }
1582 
1583   }
1584 
1585   /**
1586    * @throws Exception
1587    */
1588   public void testGroupDelete() throws Exception {
1589 
1590     PrintStream systemOut = System.out;
1591 
1592     ByteArrayOutputStream baos = new ByteArrayOutputStream();
1593     System.setOut(new PrintStream(baos));
1594 
1595     try {
1596 
1597       GrouperClient.main(GrouperClientUtils.splitTrim(
1598           "--operation=groupDeleteWs --groupNames=aStem:aGroup", " "));
1599       System.out.flush();
1600       String output = new String(baos.toByteArray());
1601 
1602       System.setOut(systemOut);
1603 
1604       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
1605 
1606       Pattern pattern = Pattern
1607           .compile("^Index (\\d+): success: T: code: ([A-Z_]+): (.*+)$");
1608       Matcher matcher = pattern.matcher(outputLines[0]);
1609 
1610       assertTrue(outputLines[0], matcher.matches());
1611 
1612       assertEquals("0", matcher.group(1));
1613       assertEquals("SUCCESS", matcher.group(2));
1614       assertEquals("aStem:aGroup", matcher.group(3));
1615 
1616       // #####################################################
1617       // run again, should be already deleted
1618       baos = new ByteArrayOutputStream();
1619       System.setOut(new PrintStream(baos));
1620 
1621       GrouperClient.main(GrouperClientUtils.splitTrim(
1622           "--operation=groupDeleteWs --groupNames=aStem:aGroup", " "));
1623       System.out.flush();
1624       output = new String(baos.toByteArray());
1625 
1626       System.setOut(systemOut);
1627 
1628       outputLines = GrouperClientUtils.splitTrim(output, "\n");
1629 
1630       matcher = pattern.matcher(outputLines[0]);
1631 
1632       assertTrue(outputLines[0], matcher.matches());
1633 
1634       assertEquals("0", matcher.group(1));
1635       assertEquals("SUCCESS_GROUP_NOT_FOUND", matcher.group(2));
1636       assertEquals("aStem:aGroup", matcher.group(3));
1637 
1638       // #####################################################
1639       // run with invalid args
1640       baos = new ByteArrayOutputStream();
1641       System.setOut(new PrintStream(baos));
1642 
1643       // test a command line template
1644       try {
1645         GrouperClient
1646             .main(GrouperClientUtils
1647                 .splitTrim(
1648                     "--operation=groupDeleteWs --groupNames=aStem:aGroup --ousdfsdfate=${index}",
1649                     " "));
1650       } catch (Exception e) {
1651         assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
1652       }
1653       System.out.flush();
1654 
1655       System.setOut(systemOut);
1656 
1657       // #####################################################
1658       // run with custom template
1659       baos = new ByteArrayOutputStream();
1660       System.setOut(new PrintStream(baos));
1661 
1662       // test a command line template
1663       GrouperClient
1664           .main(GrouperClientUtils
1665               .splitTrim(
1666                   "--operation=groupDeleteWs --groupNames=aStem:aGroup --outputTemplate=${index}",
1667                   " "));
1668 
1669       System.out.flush();
1670 
1671       output = new String(baos.toByteArray());
1672 
1673       System.setOut(systemOut);
1674 
1675       assertEquals("0", output);
1676 
1677       // #####################################################
1678       // run again, with txType
1679       baos = new ByteArrayOutputStream();
1680       System.setOut(new PrintStream(baos));
1681 
1682       GrouperClient.main(GrouperClientUtils.splitTrim(
1683           "--operation=groupDeleteWs --groupNames=aStem:aGroup --txType=NONE",
1684           " "));
1685       System.out.flush();
1686       output = new String(baos.toByteArray());
1687 
1688       System.setOut(systemOut);
1689 
1690       outputLines = GrouperClientUtils.splitTrim(output, "\n");
1691 
1692       matcher = pattern.matcher(outputLines[0]);
1693 
1694       assertTrue(outputLines[0], matcher.matches());
1695 
1696       assertEquals("0", matcher.group(1));
1697       assertEquals("SUCCESS_GROUP_NOT_FOUND", matcher.group(2));
1698       assertEquals("aStem:aGroup", matcher.group(3));
1699 
1700       assertTrue(GrouperClientWs.mostRecentRequest,
1701           GrouperClientWs.mostRecentRequest.contains("txType")
1702               && GrouperClientWs.mostRecentRequest.contains("NONE"));
1703 
1704       // #####################################################
1705       // run again, with includeSubjectDetail
1706       baos = new ByteArrayOutputStream();
1707       System.setOut(new PrintStream(baos));
1708 
1709       GrouperClient
1710           .main(GrouperClientUtils
1711               .splitTrim(
1712                   "--operation=groupDeleteWs --groupNames=aStem:aGroup --includeGroupDetail=true",
1713                   " "));
1714       System.out.flush();
1715       output = new String(baos.toByteArray());
1716 
1717       System.setOut(systemOut);
1718 
1719       outputLines = GrouperClientUtils.splitTrim(output, "\n");
1720 
1721       matcher = pattern.matcher(outputLines[0]);
1722 
1723       assertTrue(outputLines[0], matcher.matches());
1724 
1725       assertEquals("0", matcher.group(1));
1726       assertEquals("SUCCESS_GROUP_NOT_FOUND", matcher.group(2));
1727       assertEquals("aStem:aGroup", matcher.group(3));
1728 
1729       assertTrue(!GrouperClientWs.mostRecentRequest.contains("txType")
1730           && !GrouperClientWs.mostRecentRequest.contains("NONE")
1731           && GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
1732 
1733       // #####################################################
1734       // run again, with params
1735       baos = new ByteArrayOutputStream();
1736       System.setOut(new PrintStream(baos));
1737 
1738       GrouperClient
1739           .main(GrouperClientUtils
1740               .splitTrim(
1741                   "--operation=groupDeleteWs --groupNames=aStem:aGroup --paramName0=whatever --paramValue0=someValue",
1742                   " "));
1743       System.out.flush();
1744       output = new String(baos.toByteArray());
1745 
1746       System.setOut(systemOut);
1747 
1748       outputLines = GrouperClientUtils.splitTrim(output, "\n");
1749 
1750       matcher = pattern.matcher(outputLines[0]);
1751 
1752       assertTrue(outputLines[0], matcher.matches());
1753 
1754       assertEquals("0", matcher.group(1));
1755       assertEquals("SUCCESS_GROUP_NOT_FOUND", matcher.group(2));
1756       assertEquals("aStem:aGroup", matcher.group(3));
1757 
1758       assertTrue(GrouperClientWs.mostRecentRequest.contains("whatever")
1759           && GrouperClientWs.mostRecentRequest.contains("someValue"));
1760 
1761     } finally {
1762       System.setOut(systemOut);
1763     }
1764 
1765   }
1766 
1767   /**
1768    * @throws Exception
1769    */
1770   public void testStemDelete() throws Exception {
1771 
1772     PrintStream systemOut = System.out;
1773 
1774     ByteArrayOutputStream baos = new ByteArrayOutputStream();
1775     System.setOut(new PrintStream(baos));
1776 
1777     try {
1778 
1779       GrouperClient.main(GrouperClientUtils.splitTrim(
1780           "--operation=stemDeleteWs --stemNames=aStem:aStem0", " "));
1781       System.out.flush();
1782       String output = new String(baos.toByteArray());
1783 
1784       System.setOut(systemOut);
1785 
1786       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
1787 
1788       Pattern pattern = Pattern
1789           .compile("^Index (\\d+): success: T: code: ([A-Z_]+): (.*+)$");
1790       Matcher matcher = pattern.matcher(outputLines[0]);
1791 
1792       assertTrue(outputLines[0], matcher.matches());
1793 
1794       assertEquals("0", matcher.group(1));
1795       assertEquals("SUCCESS", matcher.group(2));
1796       assertEquals("aStem:aStem0", matcher.group(3));
1797 
1798       // #####################################################
1799       // run again, should be already deleted
1800       baos = new ByteArrayOutputStream();
1801       System.setOut(new PrintStream(baos));
1802 
1803       GrouperClient.main(GrouperClientUtils.splitTrim(
1804           "--operation=stemDeleteWs --stemNames=aStem:aStem0", " "));
1805       System.out.flush();
1806       output = new String(baos.toByteArray());
1807 
1808       System.setOut(systemOut);
1809 
1810       outputLines = GrouperClientUtils.splitTrim(output, "\n");
1811 
1812       matcher = pattern.matcher(outputLines[0]);
1813 
1814       assertTrue(outputLines[0], matcher.matches());
1815 
1816       assertEquals("0", matcher.group(1));
1817       assertEquals("SUCCESS_STEM_NOT_FOUND", matcher.group(2));
1818       assertEquals("aStem:aStem0", matcher.group(3));
1819 
1820       // #####################################################
1821       // run with invalid args
1822       baos = new ByteArrayOutputStream();
1823       System.setOut(new PrintStream(baos));
1824 
1825       // test a command line template
1826       try {
1827         GrouperClient
1828             .main(GrouperClientUtils
1829                 .splitTrim(
1830                     "--operation=stemDeleteWs --stemNames=aStem:aStem0 --ousdfsdfate=${index}",
1831                     " "));
1832       } catch (Exception e) {
1833         assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
1834       }
1835       System.out.flush();
1836 
1837       System.setOut(systemOut);
1838 
1839       // #####################################################
1840       // run with custom template
1841       baos = new ByteArrayOutputStream();
1842       System.setOut(new PrintStream(baos));
1843 
1844       // test a command line template
1845       GrouperClient
1846           .main(GrouperClientUtils
1847               .splitTrim(
1848                   "--operation=stemDeleteWs --stemNames=aStem:aStem0 --outputTemplate=${index}",
1849                   " "));
1850 
1851       System.out.flush();
1852 
1853       output = new String(baos.toByteArray());
1854 
1855       System.setOut(systemOut);
1856 
1857       assertEquals("0", output);
1858 
1859       // #####################################################
1860       // run again, with txType
1861       baos = new ByteArrayOutputStream();
1862       System.setOut(new PrintStream(baos));
1863 
1864       GrouperClient.main(GrouperClientUtils.splitTrim(
1865           "--operation=stemDeleteWs --stemNames=aStem:aStem0 --txType=NONE",
1866           " "));
1867       System.out.flush();
1868       output = new String(baos.toByteArray());
1869 
1870       System.setOut(systemOut);
1871 
1872       outputLines = GrouperClientUtils.splitTrim(output, "\n");
1873 
1874       matcher = pattern.matcher(outputLines[0]);
1875 
1876       assertTrue(outputLines[0], matcher.matches());
1877 
1878       assertEquals("0", matcher.group(1));
1879       assertEquals("SUCCESS_STEM_NOT_FOUND", matcher.group(2));
1880       assertEquals("aStem:aStem0", matcher.group(3));
1881 
1882       assertTrue(GrouperClientWs.mostRecentRequest,
1883           GrouperClientWs.mostRecentRequest.contains("txType")
1884               && GrouperClientWs.mostRecentRequest.contains("NONE"));
1885 
1886       // #####################################################
1887       // run again, with params
1888       baos = new ByteArrayOutputStream();
1889       System.setOut(new PrintStream(baos));
1890 
1891       GrouperClient
1892           .main(GrouperClientUtils
1893               .splitTrim(
1894                   "--operation=stemDeleteWs --stemNames=aStem:aStem0 --paramName0=whatever --paramValue0=someValue",
1895                   " "));
1896       System.out.flush();
1897       output = new String(baos.toByteArray());
1898 
1899       System.setOut(systemOut);
1900 
1901       outputLines = GrouperClientUtils.splitTrim(output, "\n");
1902 
1903       matcher = pattern.matcher(outputLines[0]);
1904 
1905       assertTrue(outputLines[0], matcher.matches());
1906 
1907       assertEquals("0", matcher.group(1));
1908       assertEquals("SUCCESS_STEM_NOT_FOUND", matcher.group(2));
1909       assertEquals("aStem:aStem0", matcher.group(3));
1910 
1911       assertTrue(GrouperClientWs.mostRecentRequest.contains("whatever")
1912           && GrouperClientWs.mostRecentRequest.contains("someValue"));
1913 
1914     } finally {
1915       System.setOut(systemOut);
1916     }
1917 
1918   }
1919 
1920   /**
1921    * normal save
1922    * @throws Exception
1923    */
1924   public void testGroupSaveNoLookup() throws Exception {
1925 
1926     WsGroupToSave wsGroupToSave = new WsGroupToSave();
1927     wsGroupToSave.setSaveMode("INSERT");
1928 
1929     WsGroup wsGroup = new WsGroup();
1930     wsGroup.setDisplayExtension("a group4");
1931     wsGroup.setExtension("aGroup4");
1932     wsGroup.setName("aStem:aGroup4");
1933     wsGroupToSave.setWsGroup(wsGroup);
1934     WsGroupSaveResults wsGroupSaveResults = new GcGroupSave().addGroupToSave(wsGroupToSave).execute();
1935 
1936     //prints SUCCESS_INSERTED when it works
1937     String resultCode = wsGroupSaveResults.getResults()[0].getResultMetadata().getResultCode();
1938 
1939     assertEquals("SUCCESS_INSERTED", resultCode);
1940   }
1941 
1942   /**
1943    * normal save
1944    * @throws Exception
1945    */
1946   public void testGroupSaveLookupNameSame() throws Exception {
1947 
1948     WsGroupToSave wsGroupToSave = new WsGroupToSave();
1949     wsGroupToSave.setSaveMode("INSERT");
1950     wsGroupToSave.setWsGroupLookup(new WsGroupLookup("aStem:aGroup4", null));
1951     WsGroup wsGroup = new WsGroup();
1952     wsGroup.setDisplayExtension("a group4");
1953     wsGroup.setExtension("aGroup4");
1954     wsGroup.setName("aStem:aGroup4");
1955     wsGroupToSave.setWsGroup(wsGroup);
1956     WsGroupSaveResults wsGroupSaveResults = new GcGroupSave().addGroupToSave(wsGroupToSave).execute();
1957 
1958     //prints SUCCESS_INSERTED when it works
1959     String resultCode = wsGroupSaveResults.getResults()[0].getResultMetadata().getResultCode();
1960 
1961     assertEquals("SUCCESS_INSERTED", resultCode);
1962   }
1963 
1964   /**
1965    * normal save
1966    * @throws Exception
1967    */
1968   public void testGroupSaveInsertAlreadyExists() throws Exception {
1969 
1970     {
1971       WsGroupToSave wsGroupToSave = new WsGroupToSave();
1972       wsGroupToSave.setSaveMode("INSERT");
1973       wsGroupToSave.setWsGroupLookup(new WsGroupLookup(null, null));
1974       WsGroup wsGroup = new WsGroup();
1975       wsGroup.setDisplayExtension("a group4");
1976       wsGroup.setExtension("aGroup4");
1977       wsGroup.setName("aStem:aGroup4");
1978       wsGroupToSave.setWsGroup(wsGroup);
1979       WsGroupSaveResults wsGroupSaveResults = new GcGroupSave().addGroupToSave(wsGroupToSave).execute();
1980 
1981       //prints SUCCESS_INSERTED when it works
1982       String resultCode = wsGroupSaveResults.getResults()[0].getResultMetadata().getResultCode();
1983 
1984       assertEquals("SUCCESS_INSERTED", resultCode);
1985     }
1986 
1987     {
1988       WsGroupToSave wsGroupToSave = new WsGroupToSave();
1989       wsGroupToSave.setSaveMode("INSERT");
1990       wsGroupToSave.setWsGroupLookup(new WsGroupLookup(null, null));
1991       WsGroup wsGroup = new WsGroup();
1992       wsGroup.setDisplayExtension("a group4");
1993       wsGroup.setExtension("aGroup4");
1994       wsGroup.setName("aStem:aGroup4");
1995       wsGroupToSave.setWsGroup(wsGroup);
1996       try {
1997         @SuppressWarnings("unused")
1998         WsGroupSaveResults wsGroupSaveResults = new GcGroupSave().addGroupToSave(wsGroupToSave).execute();
1999 
2000         fail("Should not insert twice");
2001 
2002         //System.out.println(resultCode);
2003       } catch (GcWebServiceError gwse) {
2004         WsGroupSaveResults wsGroupSaveResults = (WsGroupSaveResults)gwse.getContainerResponseObject();
2005 
2006         String resultCode = wsGroupSaveResults.getResults()[0].getResultMetadata().getResultCode();
2007 
2008         assertEquals("GROUP_ALREADY_EXISTS", resultCode);
2009       }
2010     }
2011   }
2012 
2013   /**
2014    * update a group to an existing name
2015    * @throws Exception
2016    */
2017   public void testGroupSaveUpdateExistingName() throws Exception {
2018 
2019     {
2020       WsGroupToSave wsGroupToSave = new WsGroupToSave();
2021       wsGroupToSave.setSaveMode("INSERT");
2022       wsGroupToSave.setWsGroupLookup(new WsGroupLookup(null, null));
2023       WsGroup wsGroup = new WsGroup();
2024       wsGroup.setDisplayExtension("a group4");
2025       wsGroup.setExtension("aGroup4");
2026       wsGroup.setName("aStem:aGroup4");
2027       wsGroupToSave.setWsGroup(wsGroup);
2028       WsGroupSaveResults wsGroupSaveResults = new GcGroupSave().addGroupToSave(wsGroupToSave).execute();
2029 
2030       //prints SUCCESS_INSERTED when it works
2031       String resultCode = wsGroupSaveResults.getResults()[0].getResultMetadata().getResultCode();
2032 
2033       assertEquals("SUCCESS_INSERTED", resultCode);
2034     }
2035     String uuid = null;
2036     {
2037       WsGroupToSave wsGroupToSave = new WsGroupToSave();
2038       wsGroupToSave.setSaveMode("INSERT");
2039       wsGroupToSave.setWsGroupLookup(new WsGroupLookup(null, null));
2040       WsGroup wsGroup = new WsGroup();
2041       wsGroup.setDisplayExtension("a group5");
2042       wsGroup.setExtension("aGroup5");
2043       wsGroup.setName("aStem:aGroup5");
2044       wsGroupToSave.setWsGroup(wsGroup);
2045       WsGroupSaveResults wsGroupSaveResults = new GcGroupSave().addGroupToSave(wsGroupToSave).execute();
2046 
2047       uuid = wsGroupSaveResults.getResults()[0].getWsGroup().getUuid();
2048 
2049       //prints SUCCESS_INSERTED when it works
2050       String resultCode = wsGroupSaveResults.getResults()[0].getResultMetadata().getResultCode();
2051 
2052       assertEquals("SUCCESS_INSERTED", resultCode);
2053 
2054     }
2055 
2056     {
2057       WsGroupToSave wsGroupToSave = new WsGroupToSave();
2058       wsGroupToSave.setSaveMode("UPDATE");
2059       wsGroupToSave.setWsGroupLookup(new WsGroupLookup(null, uuid));
2060       WsGroup wsGroup = new WsGroup();
2061       wsGroup.setDisplayExtension("a group4");
2062       wsGroup.setExtension("aGroup4");
2063       wsGroup.setName("aStem:aGroup4");
2064       wsGroupToSave.setWsGroup(wsGroup);
2065       try {
2066         @SuppressWarnings("unused")
2067         WsGroupSaveResults wsGroupSaveResults = new GcGroupSave().addGroupToSave(wsGroupToSave).execute();
2068 
2069         fail("Should not update to existing name");
2070 
2071         //System.out.println(resultCode);
2072       } catch (GcWebServiceError gwse) {
2073         WsGroupSaveResults wsGroupSaveResults = (WsGroupSaveResults)gwse.getContainerResponseObject();
2074 
2075         String resultCode = wsGroupSaveResults.getResults()[0].getResultMetadata().getResultCode();
2076 
2077         assertEquals("EXCEPTION", resultCode);
2078       }
2079     }
2080 
2081   }
2082 
2083   /**
2084    * @throws Exception
2085    */
2086   public void testGroupSaveMoveCopy() throws Exception {
2087 
2088     GrouperSession grouperSession = GrouperSession.startRootSession();
2089     
2090     new GroupSave(grouperSession).assignCreateParentStemsIfNotExist(true).assignName("test:testGroupToCopy").save();
2091 
2092     Group group = GroupFinder.findByName(grouperSession, "test:stemDestination:testGroupToCopy", false);
2093     
2094     if (group != null) {
2095       group.delete();
2096     }
2097     
2098     Stem toStem = new StemSave(grouperSession).assignCreateParentStemsIfNotExist(true).assignName("test:stemDestination").save();
2099     
2100     PrintStream systemOut = System.out;
2101 
2102     ByteArrayOutputStream baos = new ByteArrayOutputStream();
2103     System.setOut(new PrintStream(baos));
2104     String output = null;
2105     String[] outputLines = null;
2106     Pattern pattern = null;
2107     Matcher matcher = null;
2108     try {
2109       //try with name with slash
2110       GrouperClient.main(GrouperClientUtils.splitTrim(
2111           "--operation=groupSaveWs --name=test:testGroupToCopy --paramName0=moveOrCopy --paramValue0=copy "
2112           + "--paramName1=moveOrCopyToStemName --paramValue1=test:stemDestination "
2113           + "--paramName2=copyPrivilegesOfGroup --paramValue2=true "
2114           + "--paramName3=copyGroupAsPrivilege --paramValue3=true "
2115           + "--paramName4=copyListMembersOfGroup --paramValue4=true "
2116           + "--paramName5=copyListGroupAsMember --paramValue5=true "
2117           + "--paramName6=copyAttributes --paramValue6=true "
2118           + "  ", " "));
2119       System.out.flush();
2120       output = new String(baos.toByteArray());
2121       
2122       systemOut.println(output);
2123       
2124       System.setOut(systemOut);
2125 
2126       outputLines = GrouperClientUtils.splitTrim(output, "\n");
2127 
2128       pattern = Pattern.compile("^Success: T: code: ([A-Z_]+): (.*+)$");
2129       matcher = pattern.matcher(outputLines[0]);
2130 
2131       assertTrue(outputLines[0], matcher.matches());
2132 
2133       assertEquals("SUCCESS_INSERTED", matcher.group(1));
2134       //doesnt work
2135       //      assertEquals("test:stemDestination:testGroupToCopy", matcher.group(2));
2136       
2137       assertTrue(GrouperClientWs.mostRecentRequest,
2138           GrouperClientWs.mostRecentRequest.contains("moveOrCopy")
2139               && GrouperClientWs.mostRecentRequest.contains("copy"));
2140       assertTrue(GrouperClientWs.mostRecentRequest,
2141           GrouperClientWs.mostRecentRequest.contains("moveOrCopyToStemName")
2142               && GrouperClientWs.mostRecentRequest.contains("test:stemDestination"));
2143 
2144       group = GroupFinder.findByName(grouperSession, "test:stemDestination:testGroupToCopy", false, new QueryOptions().secondLevelCache(false));
2145       
2146       assertTrue(group != null);
2147       
2148       // #####################################################
2149       // run again, with move
2150 
2151       group = GroupFinder.findByName(grouperSession, "test:stemDestination:testGroupToCopy", true, new QueryOptions().secondLevelCache(false));
2152       
2153       if (group != null) {
2154         group.delete();
2155       }
2156 
2157       baos = new ByteArrayOutputStream();
2158       System.setOut(new PrintStream(baos));
2159 
2160       GrouperClient.main(GrouperClientUtils.splitTrim(
2161           "--operation=groupSaveWs --name=test:testGroupToCopy --paramName0=moveOrCopy --paramValue0=move "
2162           + "--paramName1=moveOrCopyToStemUuid --paramValue1=" + toStem.getUuid() + " "
2163           + "--paramName2=moveAssignAlternateName --paramValue2=false", " "));
2164       System.out.flush();
2165       output = new String(baos.toByteArray());
2166 
2167       System.setOut(systemOut);
2168 
2169       outputLines = GrouperClientUtils.splitTrim(output, "\n");
2170 
2171       pattern = Pattern.compile("^Success: T: code: ([A-Z_]+): (.*+)$");
2172       matcher = pattern.matcher(outputLines[0]);
2173 
2174       assertTrue(outputLines[0], matcher.matches());
2175 
2176       assertEquals("SUCCESS_INSERTED", matcher.group(1));
2177 
2178       //doesnt work
2179       //      assertEquals("test:stemDestination:testGroupToCopy", matcher.group(2));
2180       
2181       assertTrue(GrouperClientWs.mostRecentRequest,
2182           GrouperClientWs.mostRecentRequest.contains("moveOrCopy")
2183               && GrouperClientWs.mostRecentRequest.contains("move"));
2184       assertTrue(GrouperClientWs.mostRecentRequest,
2185           GrouperClientWs.mostRecentRequest.contains("moveAssignAlternateName")
2186               && GrouperClientWs.mostRecentRequest.contains(toStem.getUuid()));
2187 
2188       group = GroupFinder.findByName(grouperSession, "test:stemDestination:testGroupToCopy", false, new QueryOptions().secondLevelCache(false));
2189       
2190       assertTrue(group != null);
2191 
2192       group = GroupFinder.findByName(grouperSession, "test:testGroupToCopy", false, new QueryOptions().secondLevelCache(false));
2193       
2194       assertTrue(group == null);
2195 
2196     } finally {
2197       
2198     }
2199   }
2200   
2201   /**
2202    * @throws Exception
2203    */
2204   public void testStemSaveMoveCopy() throws Exception {
2205 
2206     GrouperSession grouperSession = GrouperSession.startRootSession();
2207     
2208     new StemSave(grouperSession).assignCreateParentStemsIfNotExist(true).assignName("test:testStemToCopy").save();
2209 
2210     Stem stemToCopy = StemFinder.findByName(grouperSession, "test:stemDestination:testStemToCopy", false);
2211     
2212     if (stemToCopy != null) {
2213       stemToCopy.delete();
2214     }
2215     
2216     Stem toStem = new StemSave(grouperSession).assignCreateParentStemsIfNotExist(true).assignName("test:stemDestination").save();
2217     
2218     PrintStream systemOut = System.out;
2219 
2220     ByteArrayOutputStream baos = new ByteArrayOutputStream();
2221     System.setOut(new PrintStream(baos));
2222     String output = null;
2223     String[] outputLines = null;
2224     Pattern pattern = null;
2225     Matcher matcher = null;
2226     try {
2227       //try with name with slash
2228       GrouperClient.main(GrouperClientUtils.splitTrim(
2229           "--operation=stemSaveWs --name=test:testStemToCopy --paramName0=moveOrCopy --paramValue0=copy "
2230           + "--paramName1=moveOrCopyToStemName --paramValue1=test:stemDestination "
2231           + "--paramName2=copyPrivilegesOfGroup --paramValue2=true "
2232           + "--paramName3=copyGroupAsPrivilege --paramValue3=true "
2233           + "--paramName4=copyListMembersOfGroup --paramValue4=true "
2234           + "--paramName5=copyListGroupAsMember --paramValue5=true "
2235           + "--paramName6=copyAttributes --paramValue6=true "
2236           + "--paramName7=copyPrivilegesOfStem --paramValue7=true"
2237           + "  ", " "));
2238       System.out.flush();
2239       output = new String(baos.toByteArray());
2240       
2241       systemOut.println(output);
2242       
2243       System.setOut(systemOut);
2244 
2245       outputLines = GrouperClientUtils.splitTrim(output, "\n");
2246 
2247       pattern = Pattern.compile("^Success: T: code: ([A-Z_]+): (.*+)$");
2248       matcher = pattern.matcher(outputLines[0]);
2249 
2250       assertTrue(outputLines[0], matcher.matches());
2251 
2252       assertEquals("SUCCESS_INSERTED", matcher.group(1));
2253       //doesnt work
2254       //      assertEquals("test:stemDestination:testStemToCopy", matcher.group(2));
2255       
2256       assertTrue(GrouperClientWs.mostRecentRequest,
2257           GrouperClientWs.mostRecentRequest.contains("moveOrCopy")
2258               && GrouperClientWs.mostRecentRequest.contains("copy"));
2259       assertTrue(GrouperClientWs.mostRecentRequest,
2260           GrouperClientWs.mostRecentRequest.contains("moveOrCopyToStemName")
2261               && GrouperClientWs.mostRecentRequest.contains("test:stemDestination"));
2262 
2263       stemToCopy = StemFinder.findByName(grouperSession, "test:stemDestination:testStemToCopy", false, new QueryOptions().secondLevelCache(false));
2264       
2265       assertTrue(stemToCopy != null);
2266       
2267       // #####################################################
2268       // run again, with move
2269 
2270       stemToCopy = StemFinder.findByName(grouperSession, "test:stemDestination:testStemToCopy", true, new QueryOptions().secondLevelCache(false));
2271       
2272       if (stemToCopy != null) {
2273         stemToCopy.delete();
2274       }
2275 
2276       baos = new ByteArrayOutputStream();
2277       System.setOut(new PrintStream(baos));
2278 
2279       GrouperClient.main(GrouperClientUtils.splitTrim(
2280           "--operation=stemSaveWs --name=test:testStemToCopy --paramName0=moveOrCopy --paramValue0=move "
2281           + "--paramName1=moveOrCopyToStemUuid --paramValue1=" + toStem.getUuid() + " "
2282           + "--paramName2=moveAssignAlternateName --paramValue2=false", " "));
2283       System.out.flush();
2284       output = new String(baos.toByteArray());
2285 
2286       System.setOut(systemOut);
2287 
2288       outputLines = GrouperClientUtils.splitTrim(output, "\n");
2289 
2290       pattern = Pattern.compile("^Success: T: code: ([A-Z_]+): (.*+)$");
2291       matcher = pattern.matcher(outputLines[0]);
2292 
2293       assertTrue(outputLines[0], matcher.matches());
2294 
2295       assertEquals("SUCCESS_INSERTED", matcher.group(1));
2296 
2297       //doesnt work
2298       //      assertEquals("test:stemDestination:testStemToCopy", matcher.group(2));
2299       
2300       assertTrue(GrouperClientWs.mostRecentRequest,
2301           GrouperClientWs.mostRecentRequest.contains("moveOrCopy")
2302               && GrouperClientWs.mostRecentRequest.contains("move"));
2303       assertTrue(GrouperClientWs.mostRecentRequest,
2304           GrouperClientWs.mostRecentRequest.contains("moveAssignAlternateName")
2305               && GrouperClientWs.mostRecentRequest.contains(toStem.getUuid()));
2306 
2307       stemToCopy = StemFinder.findByName(grouperSession, "test:stemDestination:testStemToCopy", false, new QueryOptions().secondLevelCache(false));
2308       
2309       assertTrue(stemToCopy != null);
2310 
2311       stemToCopy = StemFinder.findByName(grouperSession, "test:testStemToCopy", false, new QueryOptions().secondLevelCache(false));
2312       
2313       assertTrue(stemToCopy == null);
2314 
2315     } finally {
2316       
2317     }
2318   }
2319   
2320   /**
2321    * @throws Exception
2322    */
2323   public void testGroupSave() throws Exception {
2324 
2325     PrintStream systemOut = System.out;
2326 
2327     ByteArrayOutputStream baos = new ByteArrayOutputStream();
2328     System.setOut(new PrintStream(baos));
2329     String output = null;
2330     String[] outputLines = null;
2331     Pattern pattern = null;
2332     Matcher matcher = null;
2333     
2334     /**
2335     * Note that the following test uses some UTF-8
2336     * encoded characters (i.e. äöüß) that are more commonly used
2337     * by European-based languages such as German and
2338     * French. If you do not see these properly in your
2339     * development environment and/or editor and if they
2340     * show up as question marks for you, please ensure
2341     * the file encoding is correctly indicated as UTF-8.
2342     **/
2343     try {
2344       systemOut.println("Umlaut: äöüß");
2345       //try with name with slash
2346       GrouperClient.main(GrouperClientUtils.splitTrim(
2347           "--operation=groupSaveWs --name=aStem:newGroup0äöüß", " "));
2348       System.out.flush();
2349       output = new String(baos.toByteArray());
2350 
2351       systemOut.println(output);
2352 
2353       System.setOut(systemOut);
2354 
2355       outputLines = GrouperClientUtils.splitTrim(output, "\n");
2356 //äöüß
2357       pattern = Pattern.compile("^Success: T: code: ([A-Z_]+): (.*+)$");
2358       matcher = pattern.matcher(outputLines[0]);
2359 
2360       assertTrue(outputLines[0], matcher.matches());
2361 
2362       assertEquals("SUCCESS_INSERTED", matcher.group(1));
2363       assertEquals("aStem:newGroup0äöüß", matcher.group(2));
2364 
2365       // ##########################
2366       //try with name with slash
2367 
2368       baos = new ByteArrayOutputStream();
2369       System.setOut(new PrintStream(baos));
2370 
2371       GrouperClient.main(GrouperClientUtils.splitTrim(
2372           "--operation=groupSaveWs --name=aStem:newGroup0/1", " "));
2373       System.out.flush();
2374       output = new String(baos.toByteArray());
2375 
2376       System.setOut(systemOut);
2377 
2378       outputLines = GrouperClientUtils.splitTrim(output, "\n");
2379 
2380       pattern = Pattern.compile("^Success: T: code: ([A-Z_]+): (.*+)$");
2381       matcher = pattern.matcher(outputLines[0]);
2382 
2383       assertTrue(outputLines[0], matcher.matches());
2384 
2385       assertEquals("SUCCESS_INSERTED", matcher.group(1));
2386       assertEquals("aStem:newGroup0/1", matcher.group(2));
2387 
2388       // #####################################################
2389       // run again, with clientVersion
2390 
2391       baos = new ByteArrayOutputStream();
2392       System.setOut(new PrintStream(baos));
2393 
2394       GrouperClient.main(GrouperClientUtils.splitTrim(
2395           "--operation=groupSaveWs --name=aStem:newGroup0", " "));
2396       System.out.flush();
2397       output = new String(baos.toByteArray());
2398 
2399       System.setOut(systemOut);
2400 
2401       outputLines = GrouperClientUtils.splitTrim(output, "\n");
2402 
2403       pattern = Pattern.compile("^Success: T: code: ([A-Z_]+): (.*+)$");
2404       matcher = pattern.matcher(outputLines[0]);
2405 
2406       assertTrue(outputLines[0], matcher.matches());
2407 
2408       assertEquals("SUCCESS_INSERTED", matcher.group(1));
2409       assertEquals("aStem:newGroup0", matcher.group(2));
2410 
2411       // #####################################################
2412       // run again, with clientVersion
2413 
2414       baos = new ByteArrayOutputStream();
2415       System.setOut(new PrintStream(baos));
2416 
2417       GrouperClient
2418           .main(GrouperClientUtils
2419               .splitTrim(
2420                   "--operation=groupSaveWs --name=aStem:newGroup0 --clientVersion=v1_3_000",
2421                   " "));
2422       System.out.flush();
2423       output = new String(baos.toByteArray());
2424 
2425       System.setOut(systemOut);
2426 
2427       outputLines = GrouperClientUtils.splitTrim(output, "\n");
2428 
2429       matcher = pattern.matcher(outputLines[0]);
2430 
2431       assertTrue(outputLines[0], matcher.matches());
2432 
2433       assertEquals("SUCCESS", matcher.group(1));
2434       assertEquals("aStem:newGroup0", matcher.group(2));
2435 
2436       // #####################################################
2437       // run again, should be already added
2438       baos = new ByteArrayOutputStream();
2439       System.setOut(new PrintStream(baos));
2440 
2441       GrouperClient.main(GrouperClientUtils.splitTrim(
2442           "--operation=groupSaveWs --name=aStem:newGroup0", " "));
2443       System.out.flush();
2444       output = new String(baos.toByteArray());
2445 
2446       System.setOut(systemOut);
2447 
2448       outputLines = GrouperClientUtils.splitTrim(output, "\n");
2449 
2450       matcher = pattern.matcher(outputLines[0]);
2451 
2452       assertTrue(outputLines[0], matcher.matches());
2453 
2454       assertEquals("SUCCESS_NO_CHANGES_NEEDED", matcher.group(1));
2455       assertEquals("aStem:newGroup0", matcher.group(2));
2456 
2457       // #####################################################
2458       // run again, should be already added
2459       baos = new ByteArrayOutputStream();
2460       System.setOut(new PrintStream(baos));
2461 
2462       GrouperClient
2463           .main(GrouperClientUtils
2464               .splitTrim(
2465                   "--operation=groupSaveWs --name=aStem:newGroup0 --displayExtension=newGroup0displayExtension",
2466                   " "));
2467       System.out.flush();
2468       output = new String(baos.toByteArray());
2469 
2470       System.setOut(systemOut);
2471 
2472       outputLines = GrouperClientUtils.splitTrim(output, "\n");
2473 
2474       matcher = pattern.matcher(outputLines[0]);
2475 
2476       assertTrue(outputLines[0], matcher.matches());
2477 
2478       assertEquals("SUCCESS_UPDATED", matcher.group(1));
2479       assertEquals("aStem:newGroup0", matcher.group(2));
2480 
2481       // #####################################################
2482       // run with invalid args
2483       baos = new ByteArrayOutputStream();
2484       System.setOut(new PrintStream(baos));
2485 
2486       // test a command line template
2487       try {
2488         GrouperClient
2489             .main(GrouperClientUtils
2490                 .splitTrim(
2491                     "--operation=groupSaveWs --name=aStem:newGroup0 --ousdfsdfate=${index}",
2492                     " "));
2493       } catch (Exception e) {
2494         assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
2495       }
2496       System.out.flush();
2497 
2498       System.setOut(systemOut);
2499 
2500       // #####################################################
2501       // run with custom template
2502       baos = new ByteArrayOutputStream();
2503       System.setOut(new PrintStream(baos));
2504 
2505       // test a command line template
2506       GrouperClient
2507           .main(GrouperClientUtils
2508               .splitTrim(
2509                   "--operation=groupSaveWs --name=aStem:newGroup0 --outputTemplate=${index}",
2510                   " "));
2511 
2512       System.out.flush();
2513 
2514       output = new String(baos.toByteArray());
2515 
2516       System.setOut(systemOut);
2517 
2518       assertEquals("0", output);
2519 
2520       // #####################################################
2521       // run again, with field
2522       baos = new ByteArrayOutputStream();
2523       System.setOut(new PrintStream(baos));
2524 
2525       GrouperClient.main(GrouperClientUtils.splitTrim(
2526           "--operation=groupSaveWs --name=aStem:newGroup0 --saveMode=UPDATE",
2527           " "));
2528       System.out.flush();
2529       output = new String(baos.toByteArray());
2530 
2531       System.setOut(systemOut);
2532 
2533       outputLines = GrouperClientUtils.splitTrim(output, "\n");
2534 
2535       matcher = pattern.matcher(outputLines[0]);
2536 
2537       assertTrue(outputLines[0], matcher.matches());
2538 
2539       assertEquals("SUCCESS_NO_CHANGES_NEEDED", matcher.group(1));
2540       assertEquals("aStem:newGroup0", matcher.group(2));
2541 
2542       assertTrue(GrouperClientWs.mostRecentRequest,
2543           GrouperClientWs.mostRecentRequest.contains("saveMode")
2544               && GrouperClientWs.mostRecentRequest.contains("UPDATE"));
2545 
2546       // #####################################################
2547       // run again, with txType
2548       baos = new ByteArrayOutputStream();
2549       System.setOut(new PrintStream(baos));
2550 
2551       GrouperClient.main(GrouperClientUtils.splitTrim(
2552           "--operation=groupSaveWs --name=aStem:newGroup0 --txType=NONE", " "));
2553       System.out.flush();
2554       output = new String(baos.toByteArray());
2555 
2556       System.setOut(systemOut);
2557 
2558       outputLines = GrouperClientUtils.splitTrim(output, "\n");
2559 
2560       matcher = pattern.matcher(outputLines[0]);
2561 
2562       assertTrue(outputLines[0], matcher.matches());
2563 
2564       assertEquals("SUCCESS_NO_CHANGES_NEEDED", matcher.group(1));
2565       assertEquals("aStem:newGroup0", matcher.group(2));
2566 
2567       assertTrue(GrouperClientWs.mostRecentRequest,
2568           GrouperClientWs.mostRecentRequest.contains("txType")
2569               && GrouperClientWs.mostRecentRequest.contains("NONE")
2570               && !GrouperClientWs.mostRecentRequest
2571                   .contains("includeGroupDetail"));
2572 
2573       // #####################################################
2574       // run again, with includeGroupDetail
2575       baos = new ByteArrayOutputStream();
2576       System.setOut(new PrintStream(baos));
2577 
2578       GrouperClient
2579           .main(GrouperClientUtils
2580               .splitTrim(
2581                   "--operation=groupSaveWs --name=aStem:newGroup0 --includeGroupDetail=true",
2582                   " "));
2583       System.out.flush();
2584       output = new String(baos.toByteArray());
2585 
2586       System.setOut(systemOut);
2587 
2588       outputLines = GrouperClientUtils.splitTrim(output, "\n");
2589 
2590       matcher = pattern.matcher(outputLines[0]);
2591 
2592       assertTrue(outputLines[0], matcher.matches());
2593 
2594       assertEquals("SUCCESS_NO_CHANGES_NEEDED", matcher.group(1));
2595       assertEquals("aStem:newGroup0", matcher.group(2));
2596 
2597       assertTrue(!GrouperClientWs.mostRecentRequest.contains("txType")
2598           && !GrouperClientWs.mostRecentRequest.contains("NONE")
2599           && GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
2600 
2601       // #####################################################
2602       // run again, with groupLookupName
2603       baos = new ByteArrayOutputStream();
2604       System.setOut(new PrintStream(baos));
2605 
2606       GrouperClient
2607           .main(GrouperClientUtils
2608               .splitTrim(
2609                   "--operation=groupSaveWs --name=aStem:newGroup1 --groupLookupName=aStem:newGroup0",
2610                   " "));
2611       System.out.flush();
2612       output = new String(baos.toByteArray());
2613 
2614       System.setOut(systemOut);
2615 
2616       outputLines = GrouperClientUtils.splitTrim(output, "\n");
2617 
2618       matcher = pattern.matcher(outputLines[0]);
2619 
2620       assertTrue(outputLines[0], matcher.matches());
2621 
2622       assertEquals("SUCCESS_UPDATED", matcher.group(1));
2623       assertEquals("aStem:newGroup1", matcher.group(2));
2624 
2625       assertTrue(GrouperClientWs.mostRecentRequest,
2626           !GrouperClientWs.mostRecentRequest.contains("txType")
2627               && !GrouperClientWs.mostRecentRequest.contains("NONE")
2628               && !GrouperClientWs.mostRecentRequest
2629                   .contains("includeGroupDetail")
2630               && GrouperClientWs.mostRecentRequest.contains("wsGroupLookup")
2631               && GrouperClientWs.mostRecentRequest.contains("aStem:newGroup1")
2632               && GrouperClientWs.mostRecentRequest.contains("aStem:newGroup0"));
2633 
2634       // #####################################################
2635       // run again, with saveMode
2636       baos = new ByteArrayOutputStream();
2637       System.setOut(new PrintStream(baos));
2638 
2639       GrouperClient.main(GrouperClientUtils.splitTrim(
2640           "--operation=groupSaveWs --name=aStem:newGroup3 --saveMode=INSERT",
2641           " "));
2642       System.out.flush();
2643       output = new String(baos.toByteArray());
2644 
2645       System.setOut(systemOut);
2646 
2647       outputLines = GrouperClientUtils.splitTrim(output, "\n");
2648 
2649       matcher = pattern.matcher(outputLines[0]);
2650 
2651       assertTrue(outputLines[0], matcher.matches());
2652 
2653       assertEquals("SUCCESS_INSERTED", matcher.group(1));
2654       assertEquals("aStem:newGroup3", matcher.group(2));
2655 
2656       assertTrue(GrouperClientWs.mostRecentRequest.contains("saveMode")
2657           && GrouperClientWs.mostRecentRequest.contains("INSERT"));
2658 
2659       // #####################################################
2660       // run again, description
2661       baos = new ByteArrayOutputStream();
2662       System.setOut(new PrintStream(baos));
2663 
2664       try {
2665         GrouperClient
2666             .main(GrouperClientUtils
2667                 .splitTrim(
2668                     "--operation=groupSaveWs --name=aStem:newGroup0 --description=aDescription",
2669                     " "));
2670         System.out.flush();
2671         output = new String(baos.toByteArray());
2672 
2673         System.setOut(systemOut);
2674 
2675         outputLines = GrouperClientUtils.splitTrim(output, "\n");
2676 
2677         matcher = pattern.matcher(outputLines[0]);
2678 
2679         assertTrue(outputLines[0], matcher.matches());
2680 
2681         assertEquals("SUCCESS_UPDATED", matcher.group(1));
2682         assertEquals("aStem:newGroup0", matcher.group(2));
2683 
2684         assertTrue(GrouperClientWs.mostRecentRequest.contains("description")
2685             && GrouperClientWs.mostRecentRequest.contains("aDescription"));
2686 
2687         // #####################################################
2688         // run again, with params
2689         baos = new ByteArrayOutputStream();
2690         System.setOut(new PrintStream(baos));
2691 
2692         GrouperClient
2693             .main(GrouperClientUtils
2694                 .splitTrim(
2695                     "--operation=groupSaveWs --name=aStem:newGroup0 --paramName0=whatever --paramValue0=someValue",
2696                     " "));
2697         System.out.flush();
2698         output = new String(baos.toByteArray());
2699 
2700         System.setOut(systemOut);
2701 
2702         outputLines = GrouperClientUtils.splitTrim(output, "\n");
2703 
2704         matcher = pattern.matcher(outputLines[0]);
2705 
2706         assertTrue(outputLines[0], matcher.matches());
2707 
2708         assertEquals("SUCCESS_UPDATED", matcher.group(1));
2709         assertEquals("aStem:newGroup0", matcher.group(2));
2710 
2711         assertTrue(GrouperClientWs.mostRecentRequest.contains("whatever")
2712             && GrouperClientWs.mostRecentRequest.contains("someValue"));
2713 
2714         // #####################################################
2715         // run again, with typeNames
2716         baos = new ByteArrayOutputStream();
2717         System.setOut(new PrintStream(baos));
2718 
2719         GrouperClient.main(GrouperClientUtils.splitTrim(
2720             "--operation=groupSaveWs --name=aStem:newGroup0 --typeNames=aType",
2721             " "));
2722         System.out.flush();
2723         output = new String(baos.toByteArray());
2724 
2725         System.setOut(systemOut);
2726 
2727         outputLines = GrouperClientUtils.splitTrim(output, "\n");
2728 
2729         matcher = pattern.matcher(outputLines[0]);
2730 
2731         assertTrue(outputLines[0], matcher.matches());
2732 
2733         assertEquals("SUCCESS_UPDATED", matcher.group(1));
2734         assertEquals("aStem:newGroup0", matcher.group(2));
2735 
2736         assertTrue(GrouperClientWs.mostRecentRequest.contains("typeNames")
2737             && GrouperClientWs.mostRecentRequest.contains("aType"));
2738 
2739         // #####################################################
2740         // run again, with attributes
2741         baos = new ByteArrayOutputStream();
2742         System.setOut(new PrintStream(baos));
2743 
2744         GrouperClient
2745             .main(GrouperClientUtils
2746                 .splitTrim(
2747                     "--operation=groupSaveWs --name=aStem:newGroup0 --typeNames=aType --attributeName0=attr_1 --attributeValue0=whatever",
2748                     " "));
2749         System.out.flush();
2750         output = new String(baos.toByteArray());
2751 
2752         System.setOut(systemOut);
2753 
2754         outputLines = GrouperClientUtils.splitTrim(output, "\n");
2755 
2756         matcher = pattern.matcher(outputLines[0]);
2757 
2758         assertTrue(outputLines[0], matcher.matches());
2759 
2760         assertEquals("SUCCESS_UPDATED", matcher.group(1));
2761         assertEquals("aStem:newGroup0", matcher.group(2));
2762 
2763         assertTrue(GrouperClientWs.mostRecentRequest.contains("attr_1")
2764             && GrouperClientWs.mostRecentRequest.contains("whatever"));
2765 
2766         // #####################################################
2767         // run again, with groupDetailParamName0
2768         baos = new ByteArrayOutputStream();
2769         System.setOut(new PrintStream(baos));
2770 
2771         GrouperClient
2772             .main(GrouperClientUtils
2773                 .splitTrim(
2774                     "--operation=groupSaveWs --name=aStem:newGroup0 --groupDetailParamName0=something --groupDetailParamValue0=whatever",
2775                     " "));
2776         System.out.flush();
2777         output = new String(baos.toByteArray());
2778 
2779         System.setOut(systemOut);
2780 
2781         outputLines = GrouperClientUtils.splitTrim(output, "\n");
2782 
2783         matcher = pattern.matcher(outputLines[0]);
2784 
2785         assertTrue(outputLines[0], matcher.matches());
2786 
2787         assertEquals("SUCCESS_UPDATED", matcher.group(1));
2788         assertEquals("aStem:newGroup0", matcher.group(2));
2789 
2790         assertTrue(GrouperClientWs.mostRecentRequest.contains("something")
2791             && GrouperClientWs.mostRecentRequest.contains("whatever"));
2792 
2793         // #####################################################
2794         // run again, with composite
2795 
2796         GrouperClient.main(GrouperClientUtils.splitTrim(
2797             "--operation=groupSaveWs --name=aStem:leftGroup", " "));
2798         GrouperClient.main(GrouperClientUtils.splitTrim(
2799             "--operation=groupSaveWs --name=aStem:rightGroup", " "));
2800 
2801         baos = new ByteArrayOutputStream();
2802         System.setOut(new PrintStream(baos));
2803 
2804         GrouperClient
2805             .main(GrouperClientUtils
2806                 .splitTrim(
2807                     "--operation=groupSaveWs --name=aStem:newGroup0 --compositeType=union --leftGroupName=aStem:leftGroup --rightGroupName=aStem:rightGroup --includeGroupDetail=true",
2808                     " "));
2809         System.out.flush();
2810         output = new String(baos.toByteArray());
2811 
2812         System.setOut(systemOut);
2813 
2814         outputLines = GrouperClientUtils.splitTrim(output, "\n");
2815 
2816         matcher = pattern.matcher(outputLines[0]);
2817 
2818         assertTrue(outputLines[0], matcher.matches());
2819 
2820         assertEquals("SUCCESS_UPDATED", matcher.group(1));
2821         assertEquals("aStem:newGroup0", matcher.group(2));
2822 
2823         assertTrue(GrouperClientWs.mostRecentRequest.contains("union")
2824             && GrouperClientWs.mostRecentRequest.contains("aStem:leftGroup")
2825             && GrouperClientWs.mostRecentRequest.contains("aStem:rightGroup"));
2826 
2827 
2828         // #####################################################
2829         // run again, with typeOfGroup
2830         baos = new ByteArrayOutputStream();
2831         System.setOut(new PrintStream(baos));
2832 
2833         GrouperClient
2834             .main(GrouperClientUtils
2835                 .splitTrim(
2836                     "--operation=groupSaveWs --name=aStem:newGroup4 --typeOfGroup=entity",
2837                     " "));
2838         System.out.flush();
2839         output = new String(baos.toByteArray());
2840 
2841         System.setOut(systemOut);
2842 
2843         outputLines = GrouperClientUtils.splitTrim(output, "\n");
2844 
2845         matcher = pattern.matcher(outputLines[0]);
2846 
2847         assertTrue(outputLines[0], matcher.matches());
2848 
2849         assertEquals("SUCCESS_INSERTED", matcher.group(1));
2850         assertEquals("aStem:newGroup4", matcher.group(2));
2851 
2852         assertTrue(GrouperClientWs.mostRecentRequest, GrouperClientWs.mostRecentRequest.contains("<typeOfGroup>entity</typeOfGroup>"));
2853 
2854 
2855         // #####################################################
2856         // run again, with idIndex
2857         baos = new ByteArrayOutputStream();
2858         System.setOut(new PrintStream(baos));
2859 
2860         GrouperClient
2861             .main(GrouperClientUtils
2862                 .splitTrim(
2863                     "--operation=groupSaveWs --name=aStem:newGroup5 --idIndex=12345",
2864                     " "));
2865         System.out.flush();
2866         output = new String(baos.toByteArray());
2867 
2868         System.setOut(systemOut);
2869 
2870         outputLines = GrouperClientUtils.splitTrim(output, "\n");
2871 
2872         matcher = pattern.matcher(outputLines[0]);
2873 
2874         assertTrue(outputLines[0], matcher.matches());
2875 
2876         assertEquals("SUCCESS_INSERTED", matcher.group(1));
2877         assertEquals("aStem:newGroup5", matcher.group(2));
2878 
2879         assertTrue(GrouperClientWs.mostRecentRequest, GrouperClientWs.mostRecentRequest.contains("<idIndex>12345</idIndex>"));
2880         assertTrue(GrouperClientWs.mostRecentResponse, GrouperClientWs.mostRecentResponse.contains("<idIndex>12345</idIndex>"));
2881 
2882         // #####################################################
2883         // run again, with idIndex
2884         baos = new ByteArrayOutputStream();
2885         System.setOut(new PrintStream(baos));
2886 
2887         GrouperClient
2888             .main(GrouperClientUtils
2889                 .splitTrim(
2890                     "--operation=groupSaveWs --name=aStem:newGroup5 --groupLookupIdIndex=12345 --description=newDescription",
2891                     " "));
2892         System.out.flush();
2893         output = new String(baos.toByteArray());
2894 
2895         System.setOut(systemOut);
2896 
2897         outputLines = GrouperClientUtils.splitTrim(output, "\n");
2898 
2899         matcher = pattern.matcher(outputLines[0]);
2900 
2901         assertTrue(outputLines[0], matcher.matches());
2902 
2903         assertEquals("SUCCESS_UPDATED", matcher.group(1));
2904         assertEquals("aStem:newGroup5", matcher.group(2));
2905 
2906         assertTrue(GrouperClientWs.mostRecentRequest, GrouperClientWs.mostRecentRequest.contains("<idIndex>12345</idIndex>"));
2907         assertTrue(GrouperClientWs.mostRecentResponse, GrouperClientWs.mostRecentResponse.contains("<idIndex>12345</idIndex>"));
2908 
2909 
2910       } finally {
2911       }
2912     } finally {
2913       System.setOut(systemOut);
2914     }
2915 
2916   }
2917 
2918   /**
2919    * @throws Exception
2920    */
2921   public void testStemSave() throws Exception {
2922 
2923     PrintStream systemOut = System.out;
2924 
2925     ByteArrayOutputStream baos = new ByteArrayOutputStream();
2926     System.setOut(new PrintStream(baos));
2927 
2928     GrouperSession grouperSession = GrouperSession.startRootSession();
2929     Stem someStem = new StemSave(grouperSession).assignName("someStem").save();
2930     GrouperSession.stopQuietly(grouperSession);
2931     try {
2932 
2933       GrouperClient.main(GrouperClientUtils.splitTrim(
2934           "--operation=stemSaveWs --name=aStem:newStem0", " "));
2935       System.out.flush();
2936       String output = new String(baos.toByteArray());
2937 
2938       System.setOut(systemOut);
2939 
2940       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
2941 
2942       Pattern pattern = Pattern.compile("^Success: T: code: ([A-Z_]+): (.*+)$");
2943       Matcher matcher = pattern.matcher(outputLines[0]);
2944 
2945       assertTrue(outputLines[0], matcher.matches());
2946 
2947       assertEquals("SUCCESS_INSERTED", matcher.group(1));
2948       assertEquals("aStem:newStem0", matcher.group(2));
2949 
2950       // #####################################################
2951       // run again, with clientVersion
2952 
2953       baos = new ByteArrayOutputStream();
2954       System.setOut(new PrintStream(baos));
2955 
2956       GrouperClient
2957           .main(GrouperClientUtils
2958               .splitTrim(
2959                   "--operation=stemSaveWs --name=aStem:newStem0 --clientVersion=v1_3_000",
2960                   " "));
2961       System.out.flush();
2962       output = new String(baos.toByteArray());
2963 
2964       System.setOut(systemOut);
2965 
2966       outputLines = GrouperClientUtils.splitTrim(output, "\n");
2967 
2968       matcher = pattern.matcher(outputLines[0]);
2969 
2970       assertTrue(outputLines[0], matcher.matches());
2971 
2972       assertEquals("SUCCESS", matcher.group(1));
2973       assertEquals("aStem:newStem0", matcher.group(2));
2974 
2975       // #####################################################
2976       // run again, should be already added
2977       baos = new ByteArrayOutputStream();
2978       System.setOut(new PrintStream(baos));
2979 
2980       GrouperClient.main(GrouperClientUtils.splitTrim(
2981           "--operation=stemSaveWs --name=aStem:newStem0", " "));
2982       System.out.flush();
2983       output = new String(baos.toByteArray());
2984 
2985       System.setOut(systemOut);
2986 
2987       outputLines = GrouperClientUtils.splitTrim(output, "\n");
2988 
2989       matcher = pattern.matcher(outputLines[0]);
2990 
2991       assertTrue(outputLines[0], matcher.matches());
2992 
2993       assertEquals("SUCCESS_NO_CHANGES_NEEDED", matcher.group(1));
2994       assertEquals("aStem:newStem0", matcher.group(2));
2995 
2996       // #####################################################
2997       // run again, should be already added
2998       baos = new ByteArrayOutputStream();
2999       System.setOut(new PrintStream(baos));
3000 
3001       GrouperClient
3002           .main(GrouperClientUtils
3003               .splitTrim(
3004                   "--operation=stemSaveWs --name=aStem:newStem0 --displayExtension=newStem0displayExtension",
3005                   " "));
3006       System.out.flush();
3007       output = new String(baos.toByteArray());
3008 
3009       System.setOut(systemOut);
3010 
3011       outputLines = GrouperClientUtils.splitTrim(output, "\n");
3012 
3013       matcher = pattern.matcher(outputLines[0]);
3014 
3015       assertTrue(outputLines[0], matcher.matches());
3016 
3017       assertEquals("SUCCESS_UPDATED", matcher.group(1));
3018       assertEquals("aStem:newStem0", matcher.group(2));
3019 
3020       // #####################################################
3021       // run with invalid args
3022       baos = new ByteArrayOutputStream();
3023       System.setOut(new PrintStream(baos));
3024 
3025       // test a command line template
3026       try {
3027         GrouperClient
3028             .main(GrouperClientUtils
3029                 .splitTrim(
3030                     "--operation=stemSaveWs --name=aStem:newStem0 --ousdfsdfate=${index}",
3031                     " "));
3032       } catch (Exception e) {
3033         assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
3034       }
3035       System.out.flush();
3036 
3037       System.setOut(systemOut);
3038 
3039       // #####################################################
3040       // run with custom template
3041       baos = new ByteArrayOutputStream();
3042       System.setOut(new PrintStream(baos));
3043 
3044       // test a command line template
3045       GrouperClient
3046           .main(GrouperClientUtils
3047               .splitTrim(
3048                   "--operation=stemSaveWs --name=aStem:newStem0 --outputTemplate=${index}",
3049                   " "));
3050 
3051       System.out.flush();
3052 
3053       output = new String(baos.toByteArray());
3054 
3055       System.setOut(systemOut);
3056 
3057       assertEquals("0", output);
3058 
3059       // #####################################################
3060       // run with custom template with function
3061       baos = new ByteArrayOutputStream();
3062       System.setOut(new PrintStream(baos));
3063 
3064       // test a command line template
3065       GrouperClient
3066           .main(GrouperClientUtils
3067               .splitTrim(
3068                   "--operation=stemSaveWs --name=aStem:newStem0 --outputTemplate=a${grouperClientUtils.defaultString(wsStemSaveResult.resultMetadata.resfsdfCode)}",
3069                   " "));
3070 
3071       System.out.flush();
3072 
3073       output = new String(baos.toByteArray());
3074 
3075       System.setOut(systemOut);
3076 
3077       assertEquals("a", output);
3078 
3079       // #####################################################
3080       // run again, with field
3081       baos = new ByteArrayOutputStream();
3082       System.setOut(new PrintStream(baos));
3083 
3084       GrouperClient.main(GrouperClientUtils
3085           .splitTrim(
3086               "--operation=stemSaveWs --name=aStem:newStem0 --saveMode=UPDATE",
3087               " "));
3088       System.out.flush();
3089       output = new String(baos.toByteArray());
3090 
3091       System.setOut(systemOut);
3092 
3093       outputLines = GrouperClientUtils.splitTrim(output, "\n");
3094 
3095       matcher = pattern.matcher(outputLines[0]);
3096 
3097       assertTrue(outputLines[0], matcher.matches());
3098 
3099       assertEquals("SUCCESS_NO_CHANGES_NEEDED", matcher.group(1));
3100       assertEquals("aStem:newStem0", matcher.group(2));
3101 
3102       assertTrue(GrouperClientWs.mostRecentRequest,
3103           GrouperClientWs.mostRecentRequest.contains("saveMode")
3104               && GrouperClientWs.mostRecentRequest.contains("UPDATE"));
3105 
3106       // #####################################################
3107       // run again, with txType
3108       baos = new ByteArrayOutputStream();
3109       System.setOut(new PrintStream(baos));
3110 
3111       GrouperClient.main(GrouperClientUtils.splitTrim(
3112           "--operation=stemSaveWs --name=aStem:newStem0 --txType=NONE", " "));
3113       System.out.flush();
3114       output = new String(baos.toByteArray());
3115 
3116       System.setOut(systemOut);
3117 
3118       outputLines = GrouperClientUtils.splitTrim(output, "\n");
3119 
3120       matcher = pattern.matcher(outputLines[0]);
3121 
3122       assertTrue(outputLines[0], matcher.matches());
3123 
3124       assertEquals("SUCCESS_NO_CHANGES_NEEDED", matcher.group(1));
3125       assertEquals("aStem:newStem0", matcher.group(2));
3126 
3127       assertTrue(GrouperClientWs.mostRecentRequest,
3128           GrouperClientWs.mostRecentRequest.contains("txType")
3129               && GrouperClientWs.mostRecentRequest.contains("NONE")
3130               && !GrouperClientWs.mostRecentRequest
3131                   .contains("includeGroupDetail"));
3132 
3133       // #####################################################
3134       // run again, with groupLookupName
3135       baos = new ByteArrayOutputStream();
3136       System.setOut(new PrintStream(baos));
3137 
3138       GrouperClient
3139           .main(GrouperClientUtils
3140               .splitTrim(
3141                   "--operation=stemSaveWs --name=aStem:newStem1 --stemLookupName=aStem:newStem0",
3142                   " "));
3143       System.out.flush();
3144       output = new String(baos.toByteArray());
3145 
3146       System.setOut(systemOut);
3147 
3148       outputLines = GrouperClientUtils.splitTrim(output, "\n");
3149 
3150       matcher = pattern.matcher(outputLines[0]);
3151 
3152       assertTrue(outputLines[0], matcher.matches());
3153 
3154       assertEquals("SUCCESS_UPDATED", matcher.group(1));
3155       assertEquals("aStem:newStem1", matcher.group(2));
3156 
3157       assertTrue(GrouperClientWs.mostRecentRequest,
3158           GrouperClientWs.mostRecentRequest.contains("wsStemLookup")
3159               && GrouperClientWs.mostRecentRequest.contains("aStem:newStem1")
3160               && GrouperClientWs.mostRecentRequest.contains("aStem:newStem0"));
3161 
3162       //lets delete and recreate this stem...
3163       grouperSession = GrouperSession.startRootSession();
3164       try {
3165         Stem stem = StemFinder.findByName(grouperSession, "aStem:newStem0", true, new QueryOptions().secondLevelCache(false));
3166         stem.delete();
3167       } finally {
3168         GrouperSession.stopQuietly(grouperSession);
3169       }
3170 
3171       // #####################################################
3172       // run again, with saveMode
3173       baos = new ByteArrayOutputStream();
3174       System.setOut(new PrintStream(baos));
3175 
3176       GrouperClient.main(GrouperClientUtils
3177           .splitTrim(
3178               "--operation=stemSaveWs --name=aStem:newStem0 --saveMode=INSERT",
3179               " "));
3180       System.out.flush();
3181       output = new String(baos.toByteArray());
3182 
3183       System.setOut(systemOut);
3184 
3185       outputLines = GrouperClientUtils.splitTrim(output, "\n");
3186 
3187       matcher = pattern.matcher(outputLines[0]);
3188 
3189       assertTrue(outputLines[0], matcher.matches());
3190 
3191       assertEquals("SUCCESS_INSERTED", matcher.group(1));
3192       assertEquals("aStem:newStem0", matcher.group(2));
3193 
3194       assertTrue(GrouperClientWs.mostRecentRequest.contains("saveMode")
3195           && GrouperClientWs.mostRecentRequest.contains("INSERT"));
3196 
3197       // #####################################################
3198       // run again, description
3199       baos = new ByteArrayOutputStream();
3200       System.setOut(new PrintStream(baos));
3201 
3202       GrouperClient
3203           .main(GrouperClientUtils
3204               .splitTrim(
3205                   "--operation=stemSaveWs --name=aStem:newStem0 --description=aDescription",
3206                   " "));
3207       System.out.flush();
3208       output = new String(baos.toByteArray());
3209 
3210       System.setOut(systemOut);
3211 
3212       outputLines = GrouperClientUtils.splitTrim(output, "\n");
3213 
3214       matcher = pattern.matcher(outputLines[0]);
3215 
3216       assertTrue(outputLines[0], matcher.matches());
3217 
3218       assertEquals("SUCCESS_UPDATED", matcher.group(1));
3219       assertEquals("aStem:newStem0", matcher.group(2));
3220 
3221       assertTrue(GrouperClientWs.mostRecentRequest.contains("description")
3222           && GrouperClientWs.mostRecentRequest.contains("aDescription"));
3223 
3224       // #####################################################
3225       // run again, with params
3226       baos = new ByteArrayOutputStream();
3227       System.setOut(new PrintStream(baos));
3228 
3229       GrouperClient
3230           .main(GrouperClientUtils
3231               .splitTrim(
3232                   "--operation=stemSaveWs --name=aStem:newStem0 --paramName0=whatever --paramValue0=someValue",
3233                   " "));
3234       System.out.flush();
3235       output = new String(baos.toByteArray());
3236 
3237       System.setOut(systemOut);
3238 
3239       outputLines = GrouperClientUtils.splitTrim(output, "\n");
3240 
3241       matcher = pattern.matcher(outputLines[0]);
3242 
3243       assertTrue(outputLines[0], matcher.matches());
3244 
3245       assertEquals("SUCCESS_UPDATED", matcher.group(1));
3246       assertEquals("aStem:newStem0", matcher.group(2));
3247 
3248       assertTrue(GrouperClientWs.mostRecentRequest.contains("whatever")
3249           && GrouperClientWs.mostRecentRequest.contains("someValue"));
3250 
3251       // #####################################################
3252       // run again, with inserting with id index
3253       baos = new ByteArrayOutputStream();
3254       System.setOut(new PrintStream(baos));
3255 
3256       GrouperClient
3257           .main(GrouperClientUtils
3258               .splitTrim(
3259                   "--operation=stemSaveWs --name=aStem:newStem5 --idIndex=12345",
3260                   " "));
3261       System.out.flush();
3262       output = new String(baos.toByteArray());
3263 
3264       System.setOut(systemOut);
3265 
3266       outputLines = GrouperClientUtils.splitTrim(output, "\n");
3267 
3268       matcher = pattern.matcher(outputLines[0]);
3269 
3270       assertTrue(outputLines[0], matcher.matches());
3271 
3272       assertEquals("SUCCESS_INSERTED", matcher.group(1));
3273       assertEquals("aStem:newStem5", matcher.group(2));
3274 
3275       assertTrue(GrouperClientWs.mostRecentRequest.contains("idIndex"));
3276 
3277 
3278       // #####################################################
3279       // run again, with lookup by id index
3280       baos = new ByteArrayOutputStream();
3281       System.setOut(new PrintStream(baos));
3282 
3283       GrouperClient
3284           .main(GrouperClientUtils
3285               .splitTrim(
3286                   "--operation=stemSaveWs --name=someStem --description=myDescription --stemLookupIdIndex=" + someStem.getIdIndex(),
3287                   " "));
3288       System.out.flush();
3289       output = new String(baos.toByteArray());
3290 
3291       System.setOut(systemOut);
3292 
3293       outputLines = GrouperClientUtils.splitTrim(output, "\n");
3294 
3295       matcher = pattern.matcher(outputLines[0]);
3296 
3297       assertTrue(outputLines[0], matcher.matches());
3298 
3299       assertEquals("SUCCESS_UPDATED", matcher.group(1));
3300       assertEquals("someStem", matcher.group(2));
3301 
3302       assertTrue(GrouperClientWs.mostRecentRequest.contains("idIndex"));
3303 
3304     } finally {
3305       System.setOut(systemOut);
3306     }
3307 
3308   }
3309 
3310   /**
3311    * @throws Exception
3312    */
3313   public void testGetGroups() throws Exception {
3314 
3315     // make sure group exists
3316     GrouperSession grouperSession = GrouperSession.startRootSession();
3317     Group group = Group.saveGroup(grouperSession, "aStem:aGroup", null,
3318         "aStem:aGroup", "aGroup", null, null, true);
3319     Group group2 = Group.saveGroup(grouperSession, "aStem:aGroup2", null,
3320         "aStem:aGroup2", "aGroup2", null, null, true);
3321     Group group3 = Group.saveGroup(grouperSession, "aStem:aGroup3", null,
3322         "aStem:aGroup3", "aGroup3", null, null, true);
3323     Group group4 = Group.saveGroup(grouperSession, "aStem:aGroup4", null,
3324         "aStem:aGroup4", "aGroup4", null, null, true);
3325     Group group5 = Group.saveGroup(grouperSession, "aStem:aGroup5", null,
3326         "aStem:aGroup5", "aGroup5", null, null, true);
3327     Group group6 = Group.saveGroup(grouperSession, "aStem:aGroup6", null,
3328         "aStem:aGroup6", "aGroup6", null, null, true);
3329 
3330     // give permissions
3331     String wsUserLabel = GrouperClientUtils.propertiesValue(
3332         "grouperClient.webService.user.label", true);
3333     String wsUserString = GrouperClientUtils.propertiesValue(
3334         "grouperClient.webService." + wsUserLabel, true);
3335     Subject wsUser = SubjectFinder.findByIdOrIdentifier(wsUserString, true);
3336 
3337     group.grantPriv(wsUser, AccessPrivilege.READ, false);
3338     group.grantPriv(wsUser, AccessPrivilege.VIEW, false);
3339     group2.grantPriv(wsUser, AccessPrivilege.READ, false);
3340     group2.grantPriv(wsUser, AccessPrivilege.VIEW, false);
3341     group3.grantPriv(wsUser, AccessPrivilege.READ, false);
3342     group3.grantPriv(wsUser, AccessPrivilege.VIEW, false);
3343     group4.grantPriv(wsUser, AccessPrivilege.VIEW, false);
3344     group4.grantPriv(wsUser, AccessPrivilege.READ, false);
3345     group5.grantPriv(wsUser, AccessPrivilege.VIEW, false);
3346     group5.grantPriv(wsUser, AccessPrivilege.READ, false);
3347     group6.grantPriv(wsUser, AccessPrivilege.VIEW, false);
3348     group6.grantPriv(wsUser, AccessPrivilege.READ, false);
3349 
3350     // add some subjects for PIT
3351     group4.addMember(SubjectTestHelper.SUBJ0, false);
3352     group4.deleteMember(SubjectTestHelper.SUBJ0, false);
3353     Thread.sleep(100);
3354     Timestamp pointInTimeFrom = new Timestamp(new Date().getTime());
3355     Thread.sleep(100);
3356 
3357     // add some subjects
3358     group.addMember(SubjectTestHelper.SUBJ0, false);
3359     group2.addMember(SubjectTestHelper.SUBJ0, false);
3360     group2.addMember(SubjectTestHelper.SUBJ1, false);
3361     group3.addMember(SubjectTestHelper.SUBJ1, false);
3362 
3363     // add some subjects for PIT
3364     group5.addMember(SubjectTestHelper.SUBJ0, false);
3365     group5.deleteMember(SubjectTestHelper.SUBJ0, false);
3366     Thread.sleep(100);
3367     Timestamp pointInTimeTo = new Timestamp(new Date().getTime());
3368     Thread.sleep(100);
3369     group6.addMember(SubjectTestHelper.SUBJ0, false);
3370     group6.deleteMember(SubjectTestHelper.SUBJ0, false);
3371     ChangeLogTempToEntity.convertRecords();
3372 
3373 
3374     PrintStream systemOut = System.out;
3375 
3376     ByteArrayOutputStream baos = new ByteArrayOutputStream();
3377     System.setOut(new PrintStream(baos));
3378 
3379     try {
3380 
3381       GrouperClient.main(GrouperClientUtils.splitTrim(
3382           "--operation=getGroupsWs --subjectIds=test.subject.0,test.subject.1",
3383           " "));
3384       System.out.flush();
3385       String output = new String(baos.toByteArray());
3386 
3387       System.setOut(systemOut);
3388 
3389       System.out.println(output);
3390 
3391       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
3392 
3393       Pattern pattern = Pattern
3394           .compile("^SubjectIndex (\\d+): success: T: code: ([A-Z_]+): subject: (.*): groupIndex: (\\d+): (.*+)$");
3395       Matcher matcher = pattern.matcher(outputLines[0]);
3396 
3397       assertTrue(outputLines[0], matcher.matches());
3398 
3399       assertEquals("0", matcher.group(1));
3400       assertEquals("SUCCESS", matcher.group(2));
3401       assertEquals("test.subject.0", matcher.group(3));
3402       assertEquals("0", matcher.group(4));
3403       assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup",
3404           matcher.group(5))
3405           || GrouperClientUtils.equals("aStem:aGroup2", matcher.group(5)));
3406 
3407       matcher = pattern.matcher(outputLines[1]);
3408 
3409       assertTrue(outputLines[1], matcher.matches());
3410 
3411       assertEquals("0", matcher.group(1));
3412       assertEquals("SUCCESS", matcher.group(2));
3413       assertEquals("test.subject.0", matcher.group(3));
3414       assertEquals("1", matcher.group(4));
3415       assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup",
3416           matcher.group(5))
3417           || GrouperClientUtils.equals("aStem:aGroup2", matcher.group(5)));
3418 
3419       matcher = pattern.matcher(outputLines[2]);
3420 
3421       assertTrue(outputLines[2], matcher.matches());
3422 
3423       assertEquals("1", matcher.group(1));
3424       assertEquals("SUCCESS", matcher.group(2));
3425       assertEquals("test.subject.1", matcher.group(3));
3426       assertEquals("0", matcher.group(4));
3427       assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup2",
3428           matcher.group(5))
3429           || GrouperClientUtils.equals("aStem:aGroup3", matcher.group(5)));
3430 
3431       matcher = pattern.matcher(outputLines[3]);
3432 
3433       assertTrue(outputLines[3], matcher.matches());
3434 
3435       assertEquals("1", matcher.group(1));
3436       assertEquals("SUCCESS", matcher.group(2));
3437       assertEquals("test.subject.1", matcher.group(3));
3438       assertEquals("1", matcher.group(4));
3439       assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup2",
3440           matcher.group(5))
3441           || GrouperClientUtils.equals("aStem:aGroup3", matcher.group(5)));
3442 
3443       // ######################################################
3444       // Try point in time
3445 
3446       baos = new ByteArrayOutputStream();
3447       System.setOut(new PrintStream(baos));
3448 
3449       ArrayList<String> args = new ArrayList<String>();
3450       args.add("--operation=getGroupsWs");
3451       args.add("--subjectIds=test.subject.0,test.subject.1");
3452       args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTimeFrom));
3453       args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTimeTo));
3454       GrouperClient.main(args.toArray(new String[0]));
3455 
3456       System.out.flush();
3457       output = new String(baos.toByteArray());
3458 
3459       System.setOut(systemOut);
3460 
3461       System.out.println(output);
3462 
3463       outputLines = GrouperClientUtils.splitTrim(output, "\n");
3464 
3465       matcher = pattern.matcher(outputLines[0]);
3466 
3467       assertTrue(outputLines[0], matcher.matches());
3468 
3469       assertEquals("0", matcher.group(1));
3470       assertEquals("SUCCESS", matcher.group(2));
3471       assertEquals("test.subject.0", matcher.group(3));
3472       assertEquals("0", matcher.group(4));
3473       assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup", matcher.group(5))
3474           || GrouperClientUtils.equals("aStem:aGroup2", matcher.group(5))
3475           || GrouperClientUtils.equals("aStem:aGroup5", matcher.group(5)));
3476 
3477       matcher = pattern.matcher(outputLines[1]);
3478 
3479       assertTrue(outputLines[1], matcher.matches());
3480 
3481       assertEquals("0", matcher.group(1));
3482       assertEquals("SUCCESS", matcher.group(2));
3483       assertEquals("test.subject.0", matcher.group(3));
3484       assertEquals("1", matcher.group(4));
3485       assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup", matcher.group(5))
3486           || GrouperClientUtils.equals("aStem:aGroup2", matcher.group(5))
3487           || GrouperClientUtils.equals("aStem:aGroup5", matcher.group(5)));
3488 
3489       matcher = pattern.matcher(outputLines[2]);
3490 
3491       assertTrue(outputLines[2], matcher.matches());
3492 
3493       assertEquals("0", matcher.group(1));
3494       assertEquals("SUCCESS", matcher.group(2));
3495       assertEquals("test.subject.0", matcher.group(3));
3496       assertEquals("2", matcher.group(4));
3497       assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup", matcher.group(5))
3498           || GrouperClientUtils.equals("aStem:aGroup2", matcher.group(5))
3499           || GrouperClientUtils.equals("aStem:aGroup5", matcher.group(5)));
3500 
3501       matcher = pattern.matcher(outputLines[3]);
3502 
3503       assertTrue(outputLines[3], matcher.matches());
3504 
3505       assertEquals("1", matcher.group(1));
3506       assertEquals("SUCCESS", matcher.group(2));
3507       assertEquals("test.subject.1", matcher.group(3));
3508       assertEquals("0", matcher.group(4));
3509       assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup2",
3510           matcher.group(5))
3511           || GrouperClientUtils.equals("aStem:aGroup3", matcher.group(5)));
3512 
3513       matcher = pattern.matcher(outputLines[4]);
3514 
3515       assertTrue(outputLines[4], matcher.matches());
3516 
3517       assertEquals("1", matcher.group(1));
3518       assertEquals("SUCCESS", matcher.group(2));
3519       assertEquals("test.subject.1", matcher.group(3));
3520       assertEquals("1", matcher.group(4));
3521       assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup2",
3522           matcher.group(5))
3523           || GrouperClientUtils.equals("aStem:aGroup3", matcher.group(5)));
3524 
3525       // #####################################################
3526       // run with invalid args
3527       baos = new ByteArrayOutputStream();
3528       System.setOut(new PrintStream(baos));
3529 
3530       // test a command line template
3531       try {
3532         GrouperClient
3533             .main(GrouperClientUtils
3534                 .splitTrim(
3535                     "--operation=getGroupsWs --subjectIds=test.subject.0,test.subject.1 --ousdfsdfate=whatever",
3536                     " "));
3537       } catch (Exception e) {
3538         assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
3539       }
3540       System.out.flush();
3541 
3542       System.setOut(systemOut);
3543 
3544       // #####################################################
3545       // run with custom template
3546       baos = new ByteArrayOutputStream();
3547       System.setOut(new PrintStream(baos));
3548 
3549       // test a command line template
3550       GrouperClient
3551           .main(GrouperClientUtils
3552               .splitTrim(
3553                   "--operation=getGroupsWs --subjectIdentifiers=id.test.subject.0,id.test.subject.1 --outputTemplate=${subjectIndex}",
3554                   " "));
3555 
3556       System.out.flush();
3557 
3558       output = new String(baos.toByteArray());
3559 
3560       System.setOut(systemOut);
3561 
3562       assertEquals("0011", output);
3563 
3564       // #####################################################
3565       // run again, with includeGroupDetail and includeSubjectDetail
3566       baos = new ByteArrayOutputStream();
3567       System.setOut(new PrintStream(baos));
3568 
3569       GrouperClient
3570           .main(GrouperClientUtils
3571               .splitTrim(
3572                   "--operation=getGroupsWs --subjectIds=test.subject.0,test.subject.1 --includeGroupDetail=true --includeSubjectDetail=true",
3573                   " "));
3574       System.out.flush();
3575       output = new String(baos.toByteArray());
3576 
3577       System.setOut(systemOut);
3578 
3579       outputLines = GrouperClientUtils.splitTrim(output, "\n");
3580 
3581       matcher = pattern.matcher(outputLines[0]);
3582 
3583       assertTrue(outputLines[0], matcher.matches());
3584 
3585       assertEquals("0", matcher.group(1));
3586       assertEquals("SUCCESS", matcher.group(2));
3587       assertEquals("test.subject.0", matcher.group(3));
3588       assertEquals("0", matcher.group(4));
3589       assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup",
3590           matcher.group(5))
3591           || GrouperClientUtils.equals("aStem:aGroup2", matcher.group(5)));
3592 
3593       matcher = pattern.matcher(outputLines[1]);
3594 
3595       assertTrue(outputLines[1], matcher.matches());
3596 
3597       assertEquals("0", matcher.group(1));
3598       assertEquals("SUCCESS", matcher.group(2));
3599       assertEquals("test.subject.0", matcher.group(3));
3600       assertEquals("1", matcher.group(4));
3601       assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup",
3602           matcher.group(5))
3603           || GrouperClientUtils.equals("aStem:aGroup2", matcher.group(5)));
3604 
3605       matcher = pattern.matcher(outputLines[2]);
3606 
3607       assertTrue(outputLines[2], matcher.matches());
3608 
3609       assertEquals("1", matcher.group(1));
3610       assertEquals("SUCCESS", matcher.group(2));
3611       assertEquals("test.subject.1", matcher.group(3));
3612       assertEquals("0", matcher.group(4));
3613       assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup2",
3614           matcher.group(5))
3615           || GrouperClientUtils.equals("aStem:aGroup3", matcher.group(5)));
3616 
3617       matcher = pattern.matcher(outputLines[3]);
3618 
3619       assertTrue(outputLines[3], matcher.matches());
3620 
3621       assertEquals("1", matcher.group(1));
3622       assertEquals("SUCCESS", matcher.group(2));
3623       assertEquals("test.subject.1", matcher.group(3));
3624       assertEquals("1", matcher.group(4));
3625       assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup2",
3626           matcher.group(5))
3627           || GrouperClientUtils.equals("aStem:aGroup3", matcher.group(5)));
3628 
3629       assertTrue(GrouperClientWs.mostRecentRequest
3630           .contains("includeGroupDetail")
3631           && GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
3632 
3633       // #####################################################
3634       // run again, with subject attributes
3635       baos = new ByteArrayOutputStream();
3636       System.setOut(new PrintStream(baos));
3637 
3638       GrouperClient
3639           .main(GrouperClientUtils
3640               .splitTrim(
3641                   "--operation=getGroupsWs --subjectIds=test.subject.0,test.subject.1 --subjectAttributeNames=name --outputTemplate=${subjectIndex}:$space$${wsGetGroupsResult.wsSubject.getAttributeValue(0)}$newline$",
3642                   " "));
3643       System.out.flush();
3644       output = new String(baos.toByteArray());
3645 
3646       System.setOut(systemOut);
3647 
3648       outputLines = GrouperClientUtils.splitTrim(output, "\n");
3649 
3650       assertTrue(output, outputLines[0].contains("my name is test.subject.0"));
3651 
3652       assertTrue(output, outputLines[2].contains("my name is test.subject.1"));
3653 
3654       assertTrue(GrouperClientWs.mostRecentRequest.contains(">name<"));
3655       assertTrue(GrouperClientWs.mostRecentResponse
3656           .contains("my name is test.subject.0"));
3657 
3658       // #####################################################
3659       // run again, with default subject source
3660       baos = new ByteArrayOutputStream();
3661       System.setOut(new PrintStream(baos));
3662 
3663       GrouperClient
3664           .main(GrouperClientUtils
3665               .splitTrim(
3666                   "--operation=getGroupsWs --subjectIds=test.subject.0,test.subject.1 --defaultSubjectSource=jdbc",
3667                   " "));
3668       System.out.flush();
3669       output = new String(baos.toByteArray());
3670 
3671       System.setOut(systemOut);
3672 
3673       outputLines = GrouperClientUtils.splitTrim(output, "\n");
3674 
3675       matcher = pattern.matcher(outputLines[0]);
3676 
3677       assertTrue(outputLines[0], matcher.matches());
3678 
3679       assertEquals("0", matcher.group(1));
3680       assertEquals("SUCCESS", matcher.group(2));
3681       assertEquals("test.subject.0", matcher.group(3));
3682       assertEquals("0", matcher.group(4));
3683       assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup",
3684           matcher.group(5))
3685           || GrouperClientUtils.equals("aStem:aGroup2", matcher.group(5)));
3686 
3687       matcher = pattern.matcher(outputLines[1]);
3688 
3689       assertTrue(outputLines[1], matcher.matches());
3690 
3691       assertEquals("0", matcher.group(1));
3692       assertEquals("SUCCESS", matcher.group(2));
3693       assertEquals("test.subject.0", matcher.group(3));
3694       assertEquals("1", matcher.group(4));
3695       assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup",
3696           matcher.group(5))
3697           || GrouperClientUtils.equals("aStem:aGroup2", matcher.group(5)));
3698 
3699       matcher = pattern.matcher(outputLines[2]);
3700 
3701       assertTrue(outputLines[2], matcher.matches());
3702 
3703       assertEquals("1", matcher.group(1));
3704       assertEquals("SUCCESS", matcher.group(2));
3705       assertEquals("test.subject.1", matcher.group(3));
3706       assertEquals("0", matcher.group(4));
3707       assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup2",
3708           matcher.group(5))
3709           || GrouperClientUtils.equals("aStem:aGroup3", matcher.group(5)));
3710 
3711       matcher = pattern.matcher(outputLines[3]);
3712 
3713       assertTrue(outputLines[3], matcher.matches());
3714 
3715       assertEquals("1", matcher.group(1));
3716       assertEquals("SUCCESS", matcher.group(2));
3717       assertEquals("test.subject.1", matcher.group(3));
3718       assertEquals("1", matcher.group(4));
3719       assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup2",
3720           matcher.group(5))
3721           || GrouperClientUtils.equals("aStem:aGroup3", matcher.group(5)));
3722 
3723       assertTrue(GrouperClientWs.mostRecentRequest.contains("jdbc"));
3724 
3725       // #####################################################
3726       // run again, subjects ids coming from file
3727       baos = new ByteArrayOutputStream();
3728       System.setOut(new PrintStream(baos));
3729 
3730       String subjectIdsFileName = "subjectIdsFile_"
3731           + GrouperClientUtils.uniqueId() + ".txt";
3732       File subjectIdsFile = new File(subjectIdsFileName);
3733 
3734       GrouperClientUtils.saveStringIntoFile(subjectIdsFile,
3735           "test.subject.0\ntest.subject.1");
3736 
3737       try {
3738         GrouperClient.main(GrouperClientUtils.splitTrim(
3739             "--operation=getGroupsWs --subjectIdsFile=" + subjectIdsFileName,
3740             " "));
3741         System.out.flush();
3742         output = new String(baos.toByteArray());
3743 
3744         System.setOut(systemOut);
3745 
3746         outputLines = GrouperClientUtils.splitTrim(output, "\n");
3747 
3748         matcher = pattern.matcher(outputLines[0]);
3749 
3750         matcher = pattern.matcher(outputLines[0]);
3751 
3752         assertTrue(outputLines[0], matcher.matches());
3753 
3754         assertEquals("0", matcher.group(1));
3755         assertEquals("SUCCESS", matcher.group(2));
3756         assertEquals("test.subject.0", matcher.group(3));
3757         assertEquals("0", matcher.group(4));
3758         assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup",
3759             matcher.group(5))
3760             || GrouperClientUtils.equals("aStem:aGroup2", matcher.group(5)));
3761 
3762         matcher = pattern.matcher(outputLines[1]);
3763 
3764         assertTrue(outputLines[1], matcher.matches());
3765 
3766         assertEquals("0", matcher.group(1));
3767         assertEquals("SUCCESS", matcher.group(2));
3768         assertEquals("test.subject.0", matcher.group(3));
3769         assertEquals("1", matcher.group(4));
3770         assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup",
3771             matcher.group(5))
3772             || GrouperClientUtils.equals("aStem:aGroup2", matcher.group(5)));
3773 
3774         matcher = pattern.matcher(outputLines[2]);
3775 
3776         assertTrue(outputLines[2], matcher.matches());
3777 
3778         assertEquals("1", matcher.group(1));
3779         assertEquals("SUCCESS", matcher.group(2));
3780         assertEquals("test.subject.1", matcher.group(3));
3781         assertEquals("0", matcher.group(4));
3782         assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup2",
3783             matcher.group(5))
3784             || GrouperClientUtils.equals("aStem:aGroup3", matcher.group(5)));
3785 
3786         matcher = pattern.matcher(outputLines[3]);
3787 
3788         assertTrue(outputLines[3], matcher.matches());
3789 
3790         assertEquals("1", matcher.group(1));
3791         assertEquals("SUCCESS", matcher.group(2));
3792         assertEquals("test.subject.1", matcher.group(3));
3793         assertEquals("1", matcher.group(4));
3794         assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup2",
3795             matcher.group(5))
3796             || GrouperClientUtils.equals("aStem:aGroup3", matcher.group(5)));
3797 
3798         // #####################################################
3799         // run again, with params
3800         baos = new ByteArrayOutputStream();
3801         System.setOut(new PrintStream(baos));
3802 
3803         GrouperClient
3804             .main(GrouperClientUtils
3805                 .splitTrim(
3806                     "--operation=getGroupsWs --subjectIds=test.subject.0,test.subject.1 --memberFilter=Immediate",
3807                     " "));
3808         System.out.flush();
3809         output = new String(baos.toByteArray());
3810 
3811         System.setOut(systemOut);
3812 
3813         outputLines = GrouperClientUtils.splitTrim(output, "\n");
3814 
3815         matcher = pattern.matcher(outputLines[0]);
3816 
3817         assertTrue(outputLines[0], matcher.matches());
3818 
3819         assertEquals("0", matcher.group(1));
3820         assertEquals("SUCCESS", matcher.group(2));
3821         assertEquals("test.subject.0", matcher.group(3));
3822         assertEquals("0", matcher.group(4));
3823         assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup",
3824             matcher.group(5))
3825             || GrouperClientUtils.equals("aStem:aGroup2", matcher.group(5)));
3826 
3827         matcher = pattern.matcher(outputLines[1]);
3828 
3829         assertTrue(outputLines[1], matcher.matches());
3830 
3831         assertEquals("0", matcher.group(1));
3832         assertEquals("SUCCESS", matcher.group(2));
3833         assertEquals("test.subject.0", matcher.group(3));
3834         assertEquals("1", matcher.group(4));
3835         assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup",
3836             matcher.group(5))
3837             || GrouperClientUtils.equals("aStem:aGroup2", matcher.group(5)));
3838 
3839         matcher = pattern.matcher(outputLines[2]);
3840 
3841         assertTrue(outputLines[2], matcher.matches());
3842 
3843         assertEquals("1", matcher.group(1));
3844         assertEquals("SUCCESS", matcher.group(2));
3845         assertEquals("test.subject.1", matcher.group(3));
3846         assertEquals("0", matcher.group(4));
3847         assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup2",
3848             matcher.group(5))
3849             || GrouperClientUtils.equals("aStem:aGroup3", matcher.group(5)));
3850 
3851         matcher = pattern.matcher(outputLines[3]);
3852 
3853         assertTrue(outputLines[3], matcher.matches());
3854 
3855         assertEquals("1", matcher.group(1));
3856         assertEquals("SUCCESS", matcher.group(2));
3857         assertEquals("test.subject.1", matcher.group(3));
3858         assertEquals("1", matcher.group(4));
3859         assertTrue(matcher.group(5), GrouperClientUtils.equals("aStem:aGroup2",
3860             matcher.group(5))
3861             || GrouperClientUtils.equals("aStem:aGroup3", matcher.group(5)));
3862 
3863         assertTrue(GrouperClientWs.mostRecentRequest.contains("memberFilter")
3864             && GrouperClientWs.mostRecentRequest.contains("Immediate"));
3865 
3866       } finally {
3867         if (subjectIdsFile.exists()) {
3868           subjectIdsFile.delete();
3869         }
3870       }
3871     } finally {
3872       System.setOut(systemOut);
3873     }
3874 
3875   }
3876 
3877   /**
3878    * @throws Exception
3879    */
3880   public void testHasMemberNotFound() throws Exception {
3881 
3882     // make sure group exists
3883     GrouperSession grouperSession = GrouperSession.startRootSession();
3884     Group group = Group.saveGroup(grouperSession, "aStem:aGroup", null,
3885         "aStem:aGroup", "aGroup", null, null, true);
3886 
3887     // give permissions
3888     String wsUserLabel = GrouperClientUtils.propertiesValue(
3889         "grouperClient.webService.user.label", true);
3890     String wsUserString = GrouperClientUtils.propertiesValue(
3891         "grouperClient.webService." + wsUserLabel, true);
3892     Subject wsUser = SubjectFinder.findByIdOrIdentifier(wsUserString, true);
3893 
3894     group.grantPriv(wsUser, AccessPrivilege.READ, false);
3895     group.grantPriv(wsUser, AccessPrivilege.VIEW, false);
3896 
3897     // add some subjects
3898     group.addMember(SubjectTestHelper.SUBJ0, false);
3899     group.addMember(SubjectTestHelper.SUBJ1, false);
3900 
3901     PrintStream systemOut = System.out;
3902 
3903     ByteArrayOutputStream baos = new ByteArrayOutputStream();
3904     System.setOut(new PrintStream(baos));
3905 
3906     try {
3907 
3908       GrouperClient
3909           .main(GrouperClientUtils
3910               .splitTrim(
3911                   "--operation=hasMemberWs --groupName=aStem:aGroup --subjectIds=rwjdfskjlwirwklj",
3912                   " "));
3913       System.out.flush();
3914       String output = new String(baos.toByteArray());
3915 
3916       System.setOut(systemOut);
3917 
3918       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
3919 
3920       assertEquals(1, GrouperUtil.length(outputLines));
3921 
3922       Pattern pattern = Pattern
3923           .compile("^Index (\\d+): success: T: code: ([A-Z_]+): (.+): (false|true)$");
3924       Matcher matcher = pattern.matcher(outputLines[0]);
3925 
3926       assertTrue(outputLines[0], matcher.matches());
3927 
3928       assertEquals("0", matcher.group(1));
3929       assertEquals("IS_NOT_MEMBER", matcher.group(2));
3930       assertEquals("rwjdfskjlwirwklj", matcher.group(3));
3931       assertEquals("false", matcher.group(4));
3932 
3933     } finally {
3934       System.setOut(systemOut);
3935     }
3936 
3937   }
3938 
3939   /**
3940    * @throws Exception
3941    */
3942   public void testHasMember() throws Exception {
3943 
3944     // make sure group exists
3945     GrouperSession grouperSession = GrouperSession.startRootSession();
3946     Group group = Group.saveGroup(grouperSession, "aStem:aGroup", null,
3947         "aStem:aGroup", "aGroup", null, null, true);
3948 
3949     // give permissions
3950     String wsUserLabel = GrouperClientUtils.propertiesValue(
3951         "grouperClient.webService.user.label", true);
3952     String wsUserString = GrouperClientUtils.propertiesValue(
3953         "grouperClient.webService." + wsUserLabel, true);
3954     Subject wsUser = SubjectFinder.findByIdOrIdentifier(wsUserString, true);
3955 
3956     group.grantPriv(wsUser, AccessPrivilege.READ, false);
3957     group.grantPriv(wsUser, AccessPrivilege.VIEW, false);
3958 
3959     // add some subjects for PIT
3960     group.addMember(SubjectTestHelper.SUBJ2, false);
3961     group.deleteMember(SubjectTestHelper.SUBJ2, false);
3962     Thread.sleep(100);
3963     Timestamp pointInTimeFrom = new Timestamp(new Date().getTime());
3964     Thread.sleep(100);
3965 
3966     group.addMember(SubjectTestHelper.SUBJ3, false);
3967     group.deleteMember(SubjectTestHelper.SUBJ3, false);
3968 
3969     // add some subjects
3970     group.addMember(SubjectTestHelper.SUBJ0, false);
3971     group.addMember(SubjectTestHelper.SUBJ1, false);
3972 
3973     // add some subjects for PIT
3974     group.addMember(SubjectTestHelper.SUBJ4, false);
3975     group.deleteMember(SubjectTestHelper.SUBJ4, false);
3976     Thread.sleep(100);
3977     Timestamp pointInTimeTo = new Timestamp(new Date().getTime());
3978     Thread.sleep(100);
3979 
3980     group.addMember(SubjectTestHelper.SUBJ5, false);
3981     group.deleteMember(SubjectTestHelper.SUBJ5, false);
3982     ChangeLogTempToEntity.convertRecords();
3983 
3984     PrintStream systemOut = System.out;
3985 
3986     ByteArrayOutputStream baos = new ByteArrayOutputStream();
3987     System.setOut(new PrintStream(baos));
3988 
3989     try {
3990 
3991       GrouperClient
3992           .main(GrouperClientUtils
3993               .splitTrim(
3994                   "--operation=hasMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1",
3995                   " "));
3996       System.out.flush();
3997       String output = new String(baos.toByteArray());
3998 
3999       System.setOut(systemOut);
4000 
4001       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
4002 
4003       Pattern pattern = Pattern
4004           .compile("^Index (\\d+): success: T: code: ([A-Z_]+): (.+): (false|true)$");
4005       Matcher matcher = pattern.matcher(outputLines[0]);
4006 
4007       assertTrue(outputLines[0], matcher.matches());
4008 
4009       assertEquals("0", matcher.group(1));
4010       assertEquals("IS_MEMBER", matcher.group(2));
4011       assertEquals("test.subject.0", matcher.group(3));
4012       assertEquals("true", matcher.group(4));
4013 
4014       matcher = pattern.matcher(outputLines[1]);
4015 
4016       assertTrue(outputLines[1], matcher.matches());
4017 
4018       assertEquals("1", matcher.group(1));
4019       assertEquals("IS_MEMBER", matcher.group(2));
4020       assertEquals("test.subject.1", matcher.group(3));
4021       assertEquals("true", matcher.group(4));
4022 
4023       // #####################################################
4024       // run with invalid args
4025       baos = new ByteArrayOutputStream();
4026       System.setOut(new PrintStream(baos));
4027 
4028       // test a command line template
4029       try {
4030         GrouperClient
4031             .main(GrouperClientUtils
4032                 .splitTrim(
4033                     "--operation=hasMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --ousdfsdfate=${index}",
4034                     " "));
4035       } catch (Exception e) {
4036         assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
4037       }
4038       System.out.flush();
4039 
4040       System.setOut(systemOut);
4041 
4042       // #####################################################
4043       // run with custom template
4044       baos = new ByteArrayOutputStream();
4045       System.setOut(new PrintStream(baos));
4046 
4047       // test a command line template
4048       GrouperClient
4049           .main(GrouperClientUtils
4050               .splitTrim(
4051                   "--operation=hasMemberWs --groupName=aStem:aGroup --subjectIdentifiers=id.test.subject.0,id.test.subject.1 --outputTemplate=${index}",
4052                   " "));
4053 
4054       System.out.flush();
4055 
4056       output = new String(baos.toByteArray());
4057 
4058       System.setOut(systemOut);
4059 
4060       assertEquals("01", output);
4061 
4062       // #####################################################
4063       // run again, with field
4064       baos = new ByteArrayOutputStream();
4065       System.setOut(new PrintStream(baos));
4066 
4067       GrouperClient
4068           .main(GrouperClientUtils
4069               .splitTrim(
4070                   "--operation=hasMemberWs --groupName=aStem:aGroup --pennKeys=id.test.subject.0,id.test.subject.1 --fieldName=members",
4071                   " "));
4072       System.out.flush();
4073       output = new String(baos.toByteArray());
4074 
4075       System.setOut(systemOut);
4076 
4077       outputLines = GrouperClientUtils.splitTrim(output, "\n");
4078 
4079       matcher = pattern.matcher(outputLines[0]);
4080 
4081       assertTrue(outputLines[0], matcher.matches());
4082 
4083       assertEquals("0", matcher.group(1));
4084       assertEquals("IS_MEMBER", matcher.group(2));
4085       assertEquals("test.subject.0", matcher.group(3));
4086       assertEquals("true", matcher.group(4));
4087 
4088       matcher = pattern.matcher(outputLines[1]);
4089 
4090       assertTrue(outputLines[1], matcher.matches());
4091 
4092       assertEquals("1", matcher.group(1));
4093       assertEquals("IS_MEMBER", matcher.group(2));
4094       assertEquals("test.subject.1", matcher.group(3));
4095       assertEquals("true", matcher.group(4));
4096 
4097       assertTrue(GrouperClientWs.mostRecentRequest,
4098           GrouperClientWs.mostRecentRequest.contains("fieldName")
4099               && GrouperClientWs.mostRecentRequest.contains("members")
4100               && !GrouperClientWs.mostRecentRequest.contains("txType"));
4101 
4102       // #####################################################
4103       // run again, with uuid
4104       baos = new ByteArrayOutputStream();
4105       System.setOut(new PrintStream(baos));
4106 
4107       GrouperClient
4108           .main(GrouperClientUtils
4109               .splitTrim(
4110                   "--operation=hasMemberWs --groupUuid=" + group.getUuid() + " --pennKeys=id.test.subject.0,id.test.subject.1",
4111                   " "));
4112       System.out.flush();
4113       output = new String(baos.toByteArray());
4114 
4115       System.setOut(systemOut);
4116 
4117       outputLines = GrouperClientUtils.splitTrim(output, "\n");
4118 
4119       matcher = pattern.matcher(outputLines[0]);
4120 
4121       assertTrue(outputLines[0], matcher.matches());
4122 
4123       assertEquals("0", matcher.group(1));
4124       assertEquals("IS_MEMBER", matcher.group(2));
4125       assertEquals("test.subject.0", matcher.group(3));
4126       assertEquals("true", matcher.group(4));
4127 
4128       matcher = pattern.matcher(outputLines[1]);
4129 
4130       assertTrue(outputLines[1], matcher.matches());
4131 
4132       assertEquals("1", matcher.group(1));
4133       assertEquals("IS_MEMBER", matcher.group(2));
4134       assertEquals("test.subject.1", matcher.group(3));
4135       assertEquals("true", matcher.group(4));
4136 
4137       assertTrue(GrouperClientWs.mostRecentRequest,
4138           GrouperClientWs.mostRecentRequest.contains("uuid"));
4139 
4140 
4141       // #####################################################
4142       // run again, with id index
4143       baos = new ByteArrayOutputStream();
4144       System.setOut(new PrintStream(baos));
4145 
4146       GrouperClient
4147           .main(GrouperClientUtils
4148               .splitTrim(
4149                   "--operation=hasMemberWs --groupIdIndex=" + group.getIdIndex() + " --pennKeys=id.test.subject.0,id.test.subject.1",
4150                   " "));
4151       System.out.flush();
4152       output = new String(baos.toByteArray());
4153 
4154       System.setOut(systemOut);
4155 
4156       outputLines = GrouperClientUtils.splitTrim(output, "\n");
4157 
4158       matcher = pattern.matcher(outputLines[0]);
4159 
4160       assertTrue(outputLines[0], matcher.matches());
4161 
4162       assertEquals("0", matcher.group(1));
4163       assertEquals("IS_MEMBER", matcher.group(2));
4164       assertEquals("test.subject.0", matcher.group(3));
4165       assertEquals("true", matcher.group(4));
4166 
4167       matcher = pattern.matcher(outputLines[1]);
4168 
4169       assertTrue(outputLines[1], matcher.matches());
4170 
4171       assertEquals("1", matcher.group(1));
4172       assertEquals("IS_MEMBER", matcher.group(2));
4173       assertEquals("test.subject.1", matcher.group(3));
4174       assertEquals("true", matcher.group(4));
4175 
4176       assertTrue(GrouperClientWs.mostRecentRequest,
4177           GrouperClientWs.mostRecentRequest.contains("idIndex"));
4178 
4179       // #####################################################
4180       // run again, with includeGroupDetail and includeSubjectDetail
4181       baos = new ByteArrayOutputStream();
4182       System.setOut(new PrintStream(baos));
4183 
4184       GrouperClient
4185           .main(GrouperClientUtils
4186               .splitTrim(
4187                   "--operation=hasMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --includeGroupDetail=true --includeSubjectDetail=true",
4188                   " "));
4189       System.out.flush();
4190       output = new String(baos.toByteArray());
4191 
4192       System.setOut(systemOut);
4193 
4194       outputLines = GrouperClientUtils.splitTrim(output, "\n");
4195 
4196       matcher = pattern.matcher(outputLines[0]);
4197 
4198       assertTrue(outputLines[0], matcher.matches());
4199 
4200       assertEquals("0", matcher.group(1));
4201       assertEquals("IS_MEMBER", matcher.group(2));
4202       assertEquals("test.subject.0", matcher.group(3));
4203       assertEquals("true", matcher.group(4));
4204 
4205       matcher = pattern.matcher(outputLines[1]);
4206 
4207       assertTrue(outputLines[1], matcher.matches());
4208 
4209       assertEquals("1", matcher.group(1));
4210       assertEquals("IS_MEMBER", matcher.group(2));
4211       assertEquals("test.subject.1", matcher.group(3));
4212       assertEquals("true", matcher.group(4));
4213 
4214       assertTrue(!GrouperClientWs.mostRecentRequest.contains("txType")
4215           && !GrouperClientWs.mostRecentRequest.contains("NONE")
4216           && GrouperClientWs.mostRecentRequest.contains("includeGroupDetail")
4217           && GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
4218 
4219       // #####################################################
4220       // run again, with subject attributes
4221       baos = new ByteArrayOutputStream();
4222       System.setOut(new PrintStream(baos));
4223 
4224       GrouperClient
4225           .main(GrouperClientUtils
4226               .splitTrim(
4227                   "--operation=hasMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --subjectAttributeNames=name --outputTemplate=${index}:$space$${wsHasMemberResult.wsSubject.getAttributeValue(0)}$newline$",
4228                   " "));
4229       System.out.flush();
4230       output = new String(baos.toByteArray());
4231 
4232       System.setOut(systemOut);
4233 
4234       outputLines = GrouperClientUtils.splitTrim(output, "\n");
4235 
4236       assertTrue(outputLines[0], outputLines[0]
4237           .contains("my name is test.subject.0"));
4238 
4239       assertTrue(outputLines[1], outputLines[1]
4240           .contains("my name is test.subject.1"));
4241 
4242       assertTrue(GrouperClientWs.mostRecentRequest.contains(">name<"));
4243       assertTrue(GrouperClientWs.mostRecentResponse
4244           .contains("my name is test.subject.0"));
4245 
4246       // #####################################################
4247       // run again, with default subject source
4248       baos = new ByteArrayOutputStream();
4249       System.setOut(new PrintStream(baos));
4250 
4251       GrouperClient
4252           .main(GrouperClientUtils
4253               .splitTrim(
4254                   "--operation=hasMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --defaultSubjectSource=jdbc",
4255                   " "));
4256       System.out.flush();
4257       output = new String(baos.toByteArray());
4258 
4259       System.setOut(systemOut);
4260 
4261       outputLines = GrouperClientUtils.splitTrim(output, "\n");
4262 
4263       matcher = pattern.matcher(outputLines[0]);
4264 
4265       assertTrue(outputLines[0], matcher.matches());
4266 
4267       assertEquals("0", matcher.group(1));
4268       assertEquals("IS_MEMBER", matcher.group(2));
4269       assertEquals("test.subject.0", matcher.group(3));
4270       assertEquals("true", matcher.group(4));
4271 
4272       matcher = pattern.matcher(outputLines[1]);
4273 
4274       assertTrue(outputLines[1], matcher.matches());
4275 
4276       assertEquals("1", matcher.group(1));
4277       assertEquals("IS_MEMBER", matcher.group(2));
4278       assertEquals("test.subject.1", matcher.group(3));
4279       assertEquals("true", matcher.group(4));
4280 
4281       assertTrue(GrouperClientWs.mostRecentRequest.contains("jdbc"));
4282 
4283       // #####################################################
4284       // run again, subjects ids coming from file
4285       baos = new ByteArrayOutputStream();
4286       System.setOut(new PrintStream(baos));
4287 
4288       String subjectIdsFileName = "subjectIdsFile_"
4289           + GrouperClientUtils.uniqueId() + ".txt";
4290       File subjectIdsFile = new File(subjectIdsFileName);
4291 
4292       GrouperClientUtils.saveStringIntoFile(subjectIdsFile,
4293           "test.subject.0\ntest.subject.1");
4294 
4295       try {
4296         GrouperClient.main(GrouperClientUtils.splitTrim(
4297             "--operation=hasMemberWs --groupName=aStem:aGroup --subjectIdsFile="
4298                 + subjectIdsFileName, " "));
4299         System.out.flush();
4300         output = new String(baos.toByteArray());
4301 
4302         System.setOut(systemOut);
4303 
4304         outputLines = GrouperClientUtils.splitTrim(output, "\n");
4305 
4306         matcher = pattern.matcher(outputLines[0]);
4307 
4308         assertTrue(outputLines[0], matcher.matches());
4309 
4310         assertEquals("0", matcher.group(1));
4311         assertEquals("IS_MEMBER", matcher.group(2));
4312         assertEquals("test.subject.0", matcher.group(3));
4313         assertEquals("true", matcher.group(4));
4314 
4315         matcher = pattern.matcher(outputLines[1]);
4316 
4317         assertTrue(outputLines[1], matcher.matches());
4318 
4319         assertEquals("1", matcher.group(1));
4320         assertEquals("IS_MEMBER", matcher.group(2));
4321         assertEquals("test.subject.1", matcher.group(3));
4322         assertEquals("true", matcher.group(4));
4323 
4324         // #####################################################
4325         // run again, with params
4326         baos = new ByteArrayOutputStream();
4327         System.setOut(new PrintStream(baos));
4328 
4329         GrouperClient
4330             .main(GrouperClientUtils
4331                 .splitTrim(
4332                     "--operation=hasMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --paramName0=whatever --paramValue0=someValue",
4333                     " "));
4334         System.out.flush();
4335         output = new String(baos.toByteArray());
4336 
4337         System.setOut(systemOut);
4338 
4339         outputLines = GrouperClientUtils.splitTrim(output, "\n");
4340 
4341         matcher = pattern.matcher(outputLines[0]);
4342 
4343         assertTrue(outputLines[0], matcher.matches());
4344 
4345         assertEquals("0", matcher.group(1));
4346         assertEquals("IS_MEMBER", matcher.group(2));
4347         assertEquals("test.subject.0", matcher.group(3));
4348 
4349         matcher = pattern.matcher(outputLines[1]);
4350 
4351         assertTrue(outputLines[1], matcher.matches());
4352 
4353         assertEquals("1", matcher.group(1));
4354         assertEquals("IS_MEMBER", matcher.group(2));
4355         assertEquals("test.subject.1", matcher.group(3));
4356         assertEquals("true", matcher.group(4));
4357 
4358         assertTrue(GrouperClientWs.mostRecentRequest.contains("whatever")
4359             && GrouperClientWs.mostRecentRequest.contains("someValue"));
4360 
4361         // #####################################################
4362         // run again, with memberFilter
4363         baos = new ByteArrayOutputStream();
4364         System.setOut(new PrintStream(baos));
4365 
4366         GrouperClient
4367             .main(GrouperClientUtils
4368                 .splitTrim(
4369                     "--operation=hasMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --memberFilter=Immediate",
4370                     " "));
4371         System.out.flush();
4372         output = new String(baos.toByteArray());
4373 
4374         System.setOut(systemOut);
4375 
4376         outputLines = GrouperClientUtils.splitTrim(output, "\n");
4377 
4378         matcher = pattern.matcher(outputLines[0]);
4379 
4380         assertTrue(outputLines[0], matcher.matches());
4381 
4382         assertEquals("0", matcher.group(1));
4383         assertEquals("IS_MEMBER", matcher.group(2));
4384         assertEquals("test.subject.0", matcher.group(3));
4385         assertEquals("true", matcher.group(4));
4386 
4387         matcher = pattern.matcher(outputLines[1]);
4388 
4389         assertTrue(outputLines[1], matcher.matches());
4390 
4391         assertEquals("1", matcher.group(1));
4392         assertEquals("IS_MEMBER", matcher.group(2));
4393         assertEquals("test.subject.1", matcher.group(3));
4394         assertEquals("true", matcher.group(4));
4395 
4396         assertTrue(GrouperClientWs.mostRecentRequest.contains("memberFilter")
4397             && GrouperClientWs.mostRecentRequest.contains("Immediate"));
4398 
4399 
4400         // #####################################################
4401         // run again, with point in time params
4402         baos = new ByteArrayOutputStream();
4403         System.setOut(new PrintStream(baos));
4404 
4405         ArrayList<String> args = new ArrayList<String>();
4406         args.add("--operation=hasMemberWs");
4407         args.add("--groupName=aStem:aGroup");
4408         args.add("--subjectIds=test.subject.0,test.subject.1,test.subject.2,test.subject.3,test.subject.4,test.subject.5");
4409         args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTimeFrom));
4410         args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTimeTo));
4411         GrouperClient.main(args.toArray(new String[0]));
4412 
4413         System.out.flush();
4414         output = new String(baos.toByteArray());
4415 
4416         System.setOut(systemOut);
4417 
4418         outputLines = GrouperClientUtils.splitTrim(output, "\n");
4419 
4420         matcher = pattern.matcher(outputLines[0]);
4421         assertTrue(outputLines[0], matcher.matches());
4422         assertEquals("0", matcher.group(1));
4423         assertEquals("IS_MEMBER", matcher.group(2));
4424         assertEquals("test.subject.0", matcher.group(3));
4425         assertEquals("true", matcher.group(4));
4426 
4427         matcher = pattern.matcher(outputLines[1]);
4428         assertTrue(outputLines[1], matcher.matches());
4429         assertEquals("1", matcher.group(1));
4430         assertEquals("IS_MEMBER", matcher.group(2));
4431         assertEquals("test.subject.1", matcher.group(3));
4432         assertEquals("true", matcher.group(4));
4433 
4434         matcher = pattern.matcher(outputLines[2]);
4435         assertTrue(outputLines[2], matcher.matches());
4436         assertEquals("2", matcher.group(1));
4437         assertEquals("IS_NOT_MEMBER", matcher.group(2));
4438         assertEquals("test.subject.2", matcher.group(3));
4439         assertEquals("false", matcher.group(4));
4440 
4441         matcher = pattern.matcher(outputLines[3]);
4442         assertTrue(outputLines[3], matcher.matches());
4443         assertEquals("3", matcher.group(1));
4444         assertEquals("IS_MEMBER", matcher.group(2));
4445         assertEquals("test.subject.3", matcher.group(3));
4446         assertEquals("true", matcher.group(4));
4447 
4448         matcher = pattern.matcher(outputLines[4]);
4449         assertTrue(outputLines[4], matcher.matches());
4450         assertEquals("4", matcher.group(1));
4451         assertEquals("IS_MEMBER", matcher.group(2));
4452         assertEquals("test.subject.4", matcher.group(3));
4453         assertEquals("true", matcher.group(4));
4454 
4455         matcher = pattern.matcher(outputLines[5]);
4456         assertTrue(outputLines[5], matcher.matches());
4457         assertEquals("5", matcher.group(1));
4458         assertEquals("IS_NOT_MEMBER", matcher.group(2));
4459         assertEquals("test.subject.5", matcher.group(3));
4460         assertEquals("false", matcher.group(4));
4461 
4462       } finally {
4463         if (subjectIdsFile.exists()) {
4464           subjectIdsFile.delete();
4465         }
4466       }
4467     } finally {
4468       System.setOut(systemOut);
4469     }
4470 
4471   }
4472 
4473   /**
4474    * @throws Exception
4475    */
4476   public void testDeleteMember() throws Exception {
4477 
4478     // make sure group exists
4479     GrouperSession grouperSession = GrouperSession.startRootSession();
4480     Group group = Group.saveGroup(grouperSession, "aStem:aGroup", null,
4481         "aStem:aGroup", "aGroup", null, null, true);
4482 
4483     // give permissions
4484     String wsUserLabel = GrouperClientUtils.propertiesValue(
4485         "grouperClient.webService.user.label", true);
4486     String wsUserString = GrouperClientUtils.propertiesValue(
4487         "grouperClient.webService." + wsUserLabel, true);
4488     Subject wsUser = SubjectFinder.findByIdOrIdentifier(wsUserString, true);
4489 
4490     group.grantPriv(wsUser, AccessPrivilege.READ, false);
4491     group.grantPriv(wsUser, AccessPrivilege.VIEW, false);
4492     group.grantPriv(wsUser, AccessPrivilege.ADMIN, false);
4493 
4494     // add some subjects
4495     group.addMember(SubjectTestHelper.SUBJ0, false);
4496     group.addMember(SubjectTestHelper.SUBJ1, false);
4497 
4498     PrintStream systemOut = System.out;
4499 
4500     ByteArrayOutputStream baos = new ByteArrayOutputStream();
4501     System.setOut(new PrintStream(baos));
4502 
4503     try {
4504 
4505       GrouperClient.main(GrouperClientUtils.splitTrim(
4506                   "--operation=deleteMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1",
4507                   " "));
4508       System.out.flush();
4509       String output = new String(baos.toByteArray());
4510 
4511       System.setOut(systemOut);
4512 
4513       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
4514 
4515       Pattern pattern = Pattern
4516           .compile("^Index (\\d+): success: T: code: ([A-Z_]+): (.*+)$");
4517       Matcher matcher = pattern.matcher(outputLines[0]);
4518 
4519       assertTrue(outputLines[0], matcher.matches());
4520 
4521       assertEquals("0", matcher.group(1));
4522       assertEquals("SUCCESS", matcher.group(2));
4523       assertEquals("test.subject.0", matcher.group(3));
4524 
4525       matcher = pattern.matcher(outputLines[1]);
4526 
4527       assertTrue(outputLines[1], matcher.matches());
4528 
4529       assertEquals("1", matcher.group(1));
4530       assertEquals("SUCCESS", matcher.group(2));
4531       assertEquals("test.subject.1", matcher.group(3));
4532 
4533       // #####################################################
4534       // run again, should be already deleted
4535       baos = new ByteArrayOutputStream();
4536       System.setOut(new PrintStream(baos));
4537 
4538       GrouperClient.main(GrouperClientUtils
4539               .splitTrim(
4540                   "--operation=deleteMemberWs --groupName=aStem:aGroup --pennIds=test.subject.0,test.subject.1",
4541                   " "));
4542       System.out.flush();
4543       output = new String(baos.toByteArray());
4544 
4545       System.setOut(systemOut);
4546 
4547       outputLines = GrouperClientUtils.splitTrim(output, "\n");
4548 
4549       matcher = pattern.matcher(outputLines[0]);
4550 
4551       assertTrue(outputLines[0], matcher.matches());
4552 
4553       assertEquals(outputLines[0], "0", matcher.group(1));
4554       assertEquals(outputLines[0], "SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4555       assertEquals(outputLines[0], "test.subject.0", matcher.group(3));
4556 
4557       matcher = pattern.matcher(outputLines[1]);
4558 
4559       assertTrue(outputLines[1], matcher.matches());
4560 
4561       assertEquals("1", matcher.group(1));
4562       assertEquals("SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4563       assertEquals("test.subject.1", matcher.group(3));
4564 
4565 
4566       // #####################################################
4567       // run again, should be already deleted
4568       baos = new ByteArrayOutputStream();
4569       System.setOut(new PrintStream(baos));
4570 
4571       GrouperClient.main(GrouperClientUtils
4572               .splitTrim(
4573                   "--operation=deleteMemberWs --groupIdIndex=" + group.getIdIndex() + " --pennIds=test.subject.0,test.subject.1",
4574                   " "));
4575       System.out.flush();
4576       output = new String(baos.toByteArray());
4577 
4578       System.setOut(systemOut);
4579 
4580       outputLines = GrouperClientUtils.splitTrim(output, "\n");
4581 
4582       matcher = pattern.matcher(outputLines[0]);
4583 
4584       assertTrue(outputLines[0], matcher.matches());
4585 
4586       assertEquals(outputLines[0], "0", matcher.group(1));
4587       assertEquals(outputLines[0], "SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4588       assertEquals(outputLines[0], "test.subject.0", matcher.group(3));
4589 
4590       matcher = pattern.matcher(outputLines[1]);
4591 
4592       assertTrue(outputLines[1], matcher.matches());
4593 
4594       assertEquals("1", matcher.group(1));
4595       assertEquals("SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4596       assertEquals("test.subject.1", matcher.group(3));
4597 
4598       // #####################################################
4599       // run again, with uuid
4600       baos = new ByteArrayOutputStream();
4601       System.setOut(new PrintStream(baos));
4602 
4603       GrouperClient.main(GrouperClientUtils
4604               .splitTrim(
4605                   "--operation=deleteMemberWs --groupUuid=" + group.getUuid() + " --pennIds=test.subject.0,test.subject.1",
4606                   " "));
4607       System.out.flush();
4608       output = new String(baos.toByteArray());
4609 
4610       System.setOut(systemOut);
4611 
4612       outputLines = GrouperClientUtils.splitTrim(output, "\n");
4613 
4614       matcher = pattern.matcher(outputLines[0]);
4615 
4616       assertTrue(outputLines[0], matcher.matches());
4617 
4618       assertEquals(outputLines[0], "0", matcher.group(1));
4619       assertEquals(outputLines[0], "SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4620       assertEquals(outputLines[0], "test.subject.0", matcher.group(3));
4621 
4622       matcher = pattern.matcher(outputLines[1]);
4623 
4624       assertTrue(outputLines[1], matcher.matches());
4625 
4626       assertEquals("1", matcher.group(1));
4627       assertEquals("SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4628       assertEquals("test.subject.1", matcher.group(3));
4629 
4630       // #####################################################
4631       // run with invalid args
4632       baos = new ByteArrayOutputStream();
4633       System.setOut(new PrintStream(baos));
4634 
4635       // test a command line template
4636       try {
4637         GrouperClient
4638             .main(GrouperClientUtils
4639                 .splitTrim(
4640                     "--operation=deleteMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --ousdfsdfate=${index}",
4641                     " "));
4642       } catch (Exception e) {
4643         assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
4644       }
4645       System.out.flush();
4646 
4647       System.setOut(systemOut);
4648 
4649       // #####################################################
4650       // run with custom template
4651       baos = new ByteArrayOutputStream();
4652       System.setOut(new PrintStream(baos));
4653 
4654       // test a command line template
4655       GrouperClient
4656           .main(GrouperClientUtils
4657               .splitTrim(
4658                   "--operation=deleteMemberWs --groupName=aStem:aGroup --subjectIdentifiers=id.test.subject.0,id.test.subject.1 --outputTemplate=${index}",
4659                   " "));
4660 
4661       System.out.flush();
4662 
4663       output = new String(baos.toByteArray());
4664 
4665       System.setOut(systemOut);
4666 
4667       assertEquals("01", output);
4668 
4669       // #####################################################
4670       // run again, with field
4671       baos = new ByteArrayOutputStream();
4672       System.setOut(new PrintStream(baos));
4673 
4674       GrouperClient
4675           .main(GrouperClientUtils
4676               .splitTrim(
4677                   "--operation=deleteMemberWs --groupName=aStem:aGroup --pennKeys=id.test.subject.0,id.test.subject.1 --fieldName=members",
4678                   " "));
4679       System.out.flush();
4680       output = new String(baos.toByteArray());
4681 
4682       System.setOut(systemOut);
4683 
4684       outputLines = GrouperClientUtils.splitTrim(output, "\n");
4685 
4686       matcher = pattern.matcher(outputLines[0]);
4687 
4688       assertTrue(outputLines[0], matcher.matches());
4689 
4690       assertEquals("0", matcher.group(1));
4691       assertEquals("SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4692       assertEquals("test.subject.0", matcher.group(3));
4693 
4694       matcher = pattern.matcher(outputLines[1]);
4695 
4696       assertTrue(outputLines[1], matcher.matches());
4697 
4698       assertEquals("1", matcher.group(1));
4699       assertEquals("SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4700       assertEquals("test.subject.1", matcher.group(3));
4701 
4702       assertTrue(GrouperClientWs.mostRecentRequest,
4703           GrouperClientWs.mostRecentRequest.contains("fieldName")
4704               && GrouperClientWs.mostRecentRequest.contains("members")
4705               && !GrouperClientWs.mostRecentRequest.contains("txType"));
4706 
4707       // #####################################################
4708       // run again, with txType
4709       baos = new ByteArrayOutputStream();
4710       System.setOut(new PrintStream(baos));
4711 
4712       GrouperClient
4713           .main(GrouperClientUtils
4714               .splitTrim(
4715                   "--operation=deleteMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --txType=NONE",
4716                   " "));
4717       System.out.flush();
4718       output = new String(baos.toByteArray());
4719 
4720       System.setOut(systemOut);
4721 
4722       outputLines = GrouperClientUtils.splitTrim(output, "\n");
4723 
4724       matcher = pattern.matcher(outputLines[0]);
4725 
4726       assertTrue(outputLines[0], matcher.matches());
4727 
4728       assertEquals("0", matcher.group(1));
4729       assertEquals("SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4730       assertEquals("test.subject.0", matcher.group(3));
4731 
4732       matcher = pattern.matcher(outputLines[1]);
4733 
4734       assertTrue(outputLines[1], matcher.matches());
4735 
4736       assertEquals("1", matcher.group(1));
4737       assertEquals("SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4738       assertEquals("test.subject.1", matcher.group(3));
4739 
4740       assertTrue(GrouperClientWs.mostRecentRequest,
4741           !GrouperClientWs.mostRecentRequest.contains("fieldName")
4742               && !GrouperClientWs.mostRecentRequest.contains("members")
4743               && GrouperClientWs.mostRecentRequest.contains("txType")
4744               && GrouperClientWs.mostRecentRequest.contains("NONE")
4745               && !GrouperClientWs.mostRecentRequest
4746                   .contains("includeGroupDetail")
4747               && !GrouperClientWs.mostRecentRequest
4748                   .contains("includeSubjectDetail")
4749               && !GrouperClientWs.mostRecentRequest
4750                   .contains("includeGroupDetail")
4751               && !GrouperClientWs.mostRecentRequest
4752                   .contains("includeSubjectDetail"));
4753 
4754       // #####################################################
4755       // run again, with includeGroupDetail and includeSubjectDetail
4756       baos = new ByteArrayOutputStream();
4757       System.setOut(new PrintStream(baos));
4758 
4759       GrouperClient
4760           .main(GrouperClientUtils
4761               .splitTrim(
4762                   "--operation=deleteMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --includeGroupDetail=true --includeSubjectDetail=true",
4763                   " "));
4764       System.out.flush();
4765       output = new String(baos.toByteArray());
4766 
4767       System.setOut(systemOut);
4768 
4769       outputLines = GrouperClientUtils.splitTrim(output, "\n");
4770 
4771       matcher = pattern.matcher(outputLines[0]);
4772 
4773       assertTrue(outputLines[0], matcher.matches());
4774 
4775       assertEquals("0", matcher.group(1));
4776       assertEquals("SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4777       assertEquals("test.subject.0", matcher.group(3));
4778 
4779       matcher = pattern.matcher(outputLines[1]);
4780 
4781       assertTrue(outputLines[1], matcher.matches());
4782 
4783       assertEquals("1", matcher.group(1));
4784       assertEquals("SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4785       assertEquals("test.subject.1", matcher.group(3));
4786 
4787       assertTrue(!GrouperClientWs.mostRecentRequest.contains("txType")
4788           && !GrouperClientWs.mostRecentRequest.contains("NONE")
4789           && GrouperClientWs.mostRecentRequest.contains("includeGroupDetail")
4790           && GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
4791 
4792       // #####################################################
4793       // run again, with subject attributes
4794       baos = new ByteArrayOutputStream();
4795       System.setOut(new PrintStream(baos));
4796 
4797       GrouperClient
4798           .main(GrouperClientUtils
4799               .splitTrim(
4800                   "--operation=deleteMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --subjectAttributeNames=name --outputTemplate=${index}:$space$${wsDeleteMemberResult.wsSubject.getAttributeValue(0)}$newline$",
4801                   " "));
4802       System.out.flush();
4803       output = new String(baos.toByteArray());
4804 
4805       System.setOut(systemOut);
4806 
4807       outputLines = GrouperClientUtils.splitTrim(output, "\n");
4808 
4809       assertTrue(outputLines[0], outputLines[0]
4810           .contains("my name is test.subject.0"));
4811 
4812       assertTrue(outputLines[1], outputLines[1]
4813           .contains("my name is test.subject.1"));
4814 
4815       assertTrue(GrouperClientWs.mostRecentRequest.contains(">name<"));
4816       assertTrue(GrouperClientWs.mostRecentResponse
4817           .contains("my name is test.subject.0"));
4818 
4819       // #####################################################
4820       // run again, with default subject source
4821       baos = new ByteArrayOutputStream();
4822       System.setOut(new PrintStream(baos));
4823 
4824       GrouperClient
4825           .main(GrouperClientUtils
4826               .splitTrim(
4827                   "--operation=deleteMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --defaultSubjectSource=jdbc",
4828                   " "));
4829       System.out.flush();
4830       output = new String(baos.toByteArray());
4831 
4832       System.setOut(systemOut);
4833 
4834       outputLines = GrouperClientUtils.splitTrim(output, "\n");
4835 
4836       matcher = pattern.matcher(outputLines[0]);
4837 
4838       assertTrue(outputLines[0], matcher.matches());
4839 
4840       assertEquals("0", matcher.group(1));
4841       assertEquals("SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4842       assertEquals("test.subject.0", matcher.group(3));
4843 
4844       matcher = pattern.matcher(outputLines[1]);
4845 
4846       assertTrue(outputLines[1], matcher.matches());
4847 
4848       assertEquals("1", matcher.group(1));
4849       assertEquals("SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4850       assertEquals("test.subject.1", matcher.group(3));
4851 
4852       assertTrue(GrouperClientWs.mostRecentRequest.contains("jdbc"));
4853 
4854       // #####################################################
4855       // run again, subjects ids coming from file
4856       baos = new ByteArrayOutputStream();
4857       System.setOut(new PrintStream(baos));
4858 
4859       String subjectIdsFileName = "subjectIdsFile_"
4860           + GrouperClientUtils.uniqueId() + ".txt";
4861       File subjectIdsFile = new File(subjectIdsFileName);
4862 
4863       GrouperClientUtils.saveStringIntoFile(subjectIdsFile,
4864           "test.subject.0\ntest.subject.1");
4865 
4866       try {
4867         GrouperClient.main(GrouperClientUtils.splitTrim(
4868             "--operation=deleteMemberWs --groupName=aStem:aGroup --subjectIdsFile="
4869                 + subjectIdsFileName, " "));
4870         System.out.flush();
4871         output = new String(baos.toByteArray());
4872 
4873         System.setOut(systemOut);
4874 
4875         outputLines = GrouperClientUtils.splitTrim(output, "\n");
4876 
4877         matcher = pattern.matcher(outputLines[0]);
4878 
4879         assertTrue(outputLines[0], matcher.matches());
4880 
4881         assertEquals("0", matcher.group(1));
4882         assertEquals("SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4883         assertEquals("test.subject.0", matcher.group(3));
4884 
4885         matcher = pattern.matcher(outputLines[1]);
4886 
4887         assertTrue(outputLines[1], matcher.matches());
4888 
4889         assertEquals("1", matcher.group(1));
4890         assertEquals("SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4891         assertEquals("test.subject.1", matcher.group(3));
4892 
4893         // #####################################################
4894         // run again, with params
4895         baos = new ByteArrayOutputStream();
4896         System.setOut(new PrintStream(baos));
4897 
4898         GrouperClient
4899             .main(GrouperClientUtils
4900                 .splitTrim(
4901                     "--operation=deleteMemberWs --groupName=aStem:aGroup --subjectIds=test.subject.0,test.subject.1 --paramName0=whatever --paramValue0=someValue",
4902                     " "));
4903         System.out.flush();
4904         output = new String(baos.toByteArray());
4905 
4906         System.setOut(systemOut);
4907 
4908         outputLines = GrouperClientUtils.splitTrim(output, "\n");
4909 
4910         matcher = pattern.matcher(outputLines[0]);
4911 
4912         assertTrue(outputLines[0], matcher.matches());
4913 
4914         assertEquals("0", matcher.group(1));
4915         assertEquals("SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4916         assertEquals("test.subject.0", matcher.group(3));
4917 
4918         matcher = pattern.matcher(outputLines[1]);
4919 
4920         assertTrue(outputLines[1], matcher.matches());
4921 
4922         assertEquals("1", matcher.group(1));
4923         assertEquals("SUCCESS_WASNT_IMMEDIATE", matcher.group(2));
4924         assertEquals("test.subject.1", matcher.group(3));
4925 
4926         assertTrue(GrouperClientWs.mostRecentRequest.contains("whatever")
4927             && GrouperClientWs.mostRecentRequest.contains("someValue"));
4928 
4929       } finally {
4930         if (subjectIdsFile.exists()) {
4931           subjectIdsFile.delete();
4932         }
4933       }
4934     } finally {
4935       System.setOut(systemOut);
4936     }
4937 
4938   }
4939 
4940   /**
4941    * @throws Exception
4942    */
4943   public void testMemberChangeSubject() throws Exception {
4944 
4945     PrintStream systemOut = System.out;
4946 
4947     ByteArrayOutputStream baos = new ByteArrayOutputStream();
4948     System.setOut(new PrintStream(baos));
4949 
4950     try {
4951 
4952       GrouperClient
4953           .main(GrouperClientUtils
4954               .splitTrim(
4955                   "--operation=memberChangeSubjectWs --oldSubjectId=test.subject.0 --newSubjectId=test.subject.1 --actAsSubjectId=GrouperSystem",
4956                   " "));
4957       System.out.flush();
4958       String output = new String(baos.toByteArray());
4959 
4960       System.setOut(systemOut);
4961 
4962       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
4963 
4964       Pattern pattern = Pattern
4965           .compile("^Success: T: code: ([A-Z_]+): oldSubject: (.+), newSubject: (.+)$");
4966       Matcher matcher = pattern.matcher(outputLines[0]);
4967 
4968       assertEquals(1, outputLines.length);
4969       assertTrue(outputLines[0], matcher.matches());
4970 
4971       assertEquals("SUCCESS", matcher.group(1));
4972       assertEquals("test.subject.0", matcher.group(2));
4973       assertEquals("test.subject.1", matcher.group(3));
4974 
4975       // #####################################################
4976       // run again, should be already moved
4977       baos = new ByteArrayOutputStream();
4978       System.setOut(new PrintStream(baos));
4979 
4980       // this should fail with member not found
4981       try {
4982         GrouperClient
4983             .main(GrouperClientUtils
4984                 .splitTrim(
4985                     "--operation=memberChangeSubjectWs --oldSubjectId=test.subject.0 --newSubjectId=test.subject.1 --actAsSubjectId=GrouperSystem",
4986                     " "));
4987         fail("Should not get here");
4988       } catch (GcWebServiceError gwse) {
4989         WsMemberChangeSubjectResults wsMemberChangeSubjectResults = (WsMemberChangeSubjectResults) gwse
4990             .getContainerResponseObject();
4991         assertEquals("PROBLEM_WITH_CHANGE", wsMemberChangeSubjectResults
4992             .getResultMetadata().getResultCode());
4993       }
4994 
4995       // #####################################################
4996       // run with invalid args
4997       baos = new ByteArrayOutputStream();
4998       System.setOut(new PrintStream(baos));
4999 
5000       // test a command line template
5001       try {
5002         GrouperClient
5003             .main(GrouperClientUtils
5004                 .splitTrim(
5005                     "--operation=memberChangeSubjectWs --oldSubjectId=test.subject.0 --newSubjectId=test.subject.1 --actAsSubjectId=GrouperSystem --ousdfsdfate=${index}",
5006                     " "));
5007       } catch (Exception e) {
5008         assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
5009       }
5010       System.out.flush();
5011 
5012       System.setOut(systemOut);
5013 
5014       // #####################################################
5015       // run with custom template and pennkeys
5016       baos = new ByteArrayOutputStream();
5017       System.setOut(new PrintStream(baos));
5018 
5019       // test a command line template
5020       GrouperClient
5021           .main(GrouperClientUtils
5022               .splitTrim(
5023                   "--operation=memberChangeSubjectWs --oldPennKey=id.test.subject.1 --newPennKey=id.test.subject.0 --actAsPennId=GrouperSystem --outputTemplate=${index}",
5024                   " "));
5025 
5026       System.out.flush();
5027 
5028       output = new String(baos.toByteArray());
5029 
5030       System.setOut(systemOut);
5031 
5032       assertEquals("0", output);
5033 
5034       // #####################################################
5035       // run again, with delete old member
5036       baos = new ByteArrayOutputStream();
5037       System.setOut(new PrintStream(baos));
5038 
5039       GrouperClient
5040           .main(GrouperClientUtils
5041               .splitTrim(
5042                   "--operation=memberChangeSubjectWs --oldSubjectIdentifier=id.test.subject.0 --newSubjectIdentifier=id.test.subject.1 --actAsSubjectId=GrouperSystem --deleteOldMember=false",
5043                   " "));
5044       System.out.flush();
5045       output = new String(baos.toByteArray());
5046 
5047       System.setOut(systemOut);
5048 
5049       outputLines = GrouperClientUtils.splitTrim(output, "\n");
5050 
5051       matcher = pattern.matcher(outputLines[0]);
5052 
5053       assertEquals(1, outputLines.length);
5054       assertTrue(outputLines[0], matcher.matches());
5055 
5056       assertEquals("SUCCESS", matcher.group(1));
5057       assertEquals("test.subject.0", matcher.group(2));
5058       assertEquals("test.subject.1", matcher.group(3));
5059 
5060       assertTrue(GrouperClientWs.mostRecentRequest,
5061           GrouperClientWs.mostRecentRequest.contains("deleteOldMember"));
5062 
5063       // #####################################################
5064       // run again, with includeSubjectDetail
5065       baos = new ByteArrayOutputStream();
5066       System.setOut(new PrintStream(baos));
5067 
5068       GrouperClient
5069           .main(GrouperClientUtils
5070               .splitTrim(
5071                   "--operation=memberChangeSubjectWs --oldSubjectId=test.subject.1 --newSubjectId=test.subject.0 --actAsSubjectId=GrouperSystem --includeSubjectDetail=true",
5072                   " "));
5073       System.out.flush();
5074       output = new String(baos.toByteArray());
5075 
5076       System.setOut(systemOut);
5077 
5078       outputLines = GrouperClientUtils.splitTrim(output, "\n");
5079 
5080       matcher = pattern.matcher(outputLines[0]);
5081 
5082       assertEquals(1, outputLines.length);
5083       assertTrue(outputLines[0], matcher.matches());
5084 
5085       assertEquals("SUCCESS", matcher.group(1));
5086       assertEquals("test.subject.1", matcher.group(2));
5087       assertEquals("test.subject.0", matcher.group(3));
5088 
5089       assertTrue(GrouperClientWs.mostRecentRequest
5090           .contains("includeSubjectDetail"));
5091 
5092       // #####################################################
5093       // run again, with subject attributes
5094       baos = new ByteArrayOutputStream();
5095       System.setOut(new PrintStream(baos));
5096 
5097       GrouperClient
5098           .main(GrouperClientUtils
5099               .splitTrim(
5100                   "--operation=memberChangeSubjectWs --oldSubjectId=test.subject.0 --newSubjectId=test.subject.1 --actAsSubjectId=GrouperSystem --subjectAttributeNames=name --outputTemplate=${index}:$space$${wsSubjectOld.getAttributeValue(0)}$newline$",
5101                   " "));
5102       System.out.flush();
5103       output = new String(baos.toByteArray());
5104 
5105       System.setOut(systemOut);
5106 
5107       outputLines = GrouperClientUtils.splitTrim(output, "\n");
5108 
5109       assertTrue(outputLines[0], outputLines[0]
5110           .contains("my name is test.subject.0"));
5111 
5112       assertTrue(GrouperClientWs.mostRecentRequest.contains(">name<"));
5113       assertTrue(GrouperClientWs.mostRecentResponse
5114           .contains("my name is test.subject.0"));
5115 
5116       // #####################################################
5117       // run again, with params
5118       baos = new ByteArrayOutputStream();
5119       System.setOut(new PrintStream(baos));
5120 
5121       GrouperClient
5122           .main(GrouperClientUtils
5123               .splitTrim(
5124                   "--operation=memberChangeSubjectWs --oldSubjectId=test.subject.1 --newSubjectId=test.subject.0 --actAsSubjectId=GrouperSystem --paramName0=whatever --paramValue0=someValue",
5125                   " "));
5126       System.out.flush();
5127       output = new String(baos.toByteArray());
5128 
5129       System.setOut(systemOut);
5130 
5131       outputLines = GrouperClientUtils.splitTrim(output, "\n");
5132 
5133       matcher = pattern.matcher(outputLines[0]);
5134 
5135       assertEquals(1, outputLines.length);
5136       assertTrue(outputLines[0], matcher.matches());
5137 
5138       assertEquals("SUCCESS", matcher.group(1));
5139       assertEquals("test.subject.1", matcher.group(2));
5140       assertEquals("test.subject.0", matcher.group(3));
5141 
5142       assertTrue(GrouperClientWs.mostRecentRequest.contains("whatever")
5143           && GrouperClientWs.mostRecentRequest.contains("someValue"));
5144 
5145     } finally {
5146       System.setOut(systemOut);
5147     }
5148 
5149   }
5150 
5151   /**
5152    * @throws Exception
5153    */
5154   public void testSendFile() throws Exception {
5155 
5156     PrintStream systemOut = System.out;
5157 
5158     ByteArrayOutputStream baos = new ByteArrayOutputStream();
5159     System.setOut(new PrintStream(baos));
5160 
5161     File file = new File("testSendFile.txt");
5162     file.deleteOnExit();
5163 
5164     try {
5165       String contents = "<WsRestAddMemberRequest>"
5166           + "<wsGroupLookup><groupName>aStem:aGroup</groupName></wsGroupLookup>"
5167           + "<subjectLookups><WsSubjectLookup>"
5168           + "<subjectId>test.subject.0</subjectId></WsSubjectLookup>"
5169           + "</subjectLookups></WsRestAddMemberRequest>";
5170       GrouperClientUtils.saveStringIntoFile(file, contents);
5171 
5172       GrouperClient
5173           .main(GrouperClientUtils
5174               .splitTrim(
5175                   "--operation=sendFile --fileName=testSendFile.txt --urlSuffix=groups/aStem:aGroup/members",
5176                   " "));
5177       System.out.flush();
5178       String output = new String(baos.toByteArray());
5179 
5180       System.setOut(systemOut);
5181 
5182       assertTrue(output.contains("<resultCode>SUCCESS</resultCode>")
5183           && output.contains("        "));
5184 
5185       // #####################################################
5186       // run again, with contents, and no formatting
5187       baos = new ByteArrayOutputStream();
5188       System.setOut(new PrintStream(baos));
5189 
5190       GrouperClient
5191           .main(GrouperClientUtils
5192               .splitTrim(
5193                   "--operation=sendFile --fileContents="
5194                       + contents
5195                       + " --urlSuffix=groups/aStem:aGroup/members --indentOutput=false",
5196                   " "));
5197 
5198       System.out.flush();
5199       output = new String(baos.toByteArray());
5200 
5201       System.setOut(systemOut);
5202 
5203       assertTrue(output.contains("<resultCode>SUCCESS</resultCode>")
5204           && !output.contains("        "));
5205 
5206     } finally {
5207       System.setOut(systemOut);
5208       file.delete();
5209     }
5210 
5211   }
5212 
5213   /**
5214    * @throws Exception
5215    */
5216   public void testFindGroups() throws Exception {
5217 
5218     // set some stuff to query
5219     GrouperSession grouperSession = GrouperSession.startRootSession();
5220     Group group = GroupFinder.findByName(grouperSession, "aStem:aGroup", true);
5221 
5222     GroupType groupType = GroupTypeFinder.find("aType", true);
5223     group.addType(groupType, false);
5224     group.setAttribute("attr_1", "something");
5225     group.store();
5226 
5227     PrintStream systemOut = System.out;
5228 
5229     ByteArrayOutputStream baos = new ByteArrayOutputStream();
5230     System.setOut(new PrintStream(baos));
5231 
5232     try {
5233 
5234       GrouperClient
5235           .main(GrouperClientUtils
5236               .splitTrim(
5237                   "--operation=findGroupsWs --queryFilterType=FIND_BY_GROUP_NAME_APPROXIMATE --groupName=aStem:aGroup",
5238                   " "));
5239       System.out.flush();
5240       String output = new String(baos.toByteArray());
5241 
5242       System.setOut(systemOut);
5243 
5244       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
5245 
5246       Pattern pattern = Pattern
5247           .compile("^Index (\\d+): name: (.+), displayName: (.+)$");
5248       Matcher matcher = pattern.matcher(outputLines[0]);
5249 
5250       assertEquals(output, 1, outputLines.length);
5251       assertTrue(outputLines[0], matcher.matches());
5252 
5253       assertEquals(output, "0", matcher.group(1));
5254       assertEquals(output, "aStem:aGroup", matcher.group(2));
5255       assertEquals(output, "aStem:aGroup", matcher.group(3));
5256 
5257       // #####################################################
5258       // filter by stem which doesnt exist, should be success
5259 
5260       baos = new ByteArrayOutputStream();
5261       System.setOut(new PrintStream(baos));
5262 
5263       GrouperClient
5264         .main(GrouperClientUtils
5265             .splitTrim(
5266                 "--operation=findGroupsWs --queryFilterType=FIND_BY_STEM_NAME --stemName=a:b:doesntExist",
5267                 " "));
5268       System.out.flush();
5269       output = new String(baos.toByteArray());
5270 
5271       System.setOut(systemOut);
5272 
5273       outputLines = GrouperClientUtils.splitTrim(output, "\n");
5274 
5275       assertEquals(output, 0, GrouperUtil.length(outputLines));
5276 
5277       System.out.flush();
5278 
5279       System.setOut(systemOut);
5280 
5281 
5282       // #####################################################
5283       // run with invalid args
5284       baos = new ByteArrayOutputStream();
5285       System.setOut(new PrintStream(baos));
5286 
5287       // test a command line template
5288       try {
5289         GrouperClient
5290             .main(GrouperClientUtils
5291                 .splitTrim(
5292                     "--operation=findGroupsWs --queryFilterType=FIND_BY_GROUP_NAME_APPROXIMATE --groupName=aStem:aGroup --ousdfsdfate=${index}",
5293                     " "));
5294       } catch (Exception e) {
5295         assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
5296       }
5297       System.out.flush();
5298 
5299       System.setOut(systemOut);
5300 
5301       // #####################################################
5302       // run with custom template
5303       baos = new ByteArrayOutputStream();
5304       System.setOut(new PrintStream(baos));
5305 
5306       // test a command line template
5307       GrouperClient
5308           .main(GrouperClientUtils
5309               .splitTrim(
5310                   "--operation=findGroupsWs --queryFilterType=FIND_BY_GROUP_NAME_APPROXIMATE --groupName=aStem:aGroup --outputTemplate=${index}",
5311                   " "));
5312 
5313       System.out.flush();
5314 
5315       output = new String(baos.toByteArray());
5316 
5317       System.setOut(systemOut);
5318 
5319       assertEquals("0", output);
5320 
5321       // #####################################################
5322       // run again, with includeGroupDetail
5323       baos = new ByteArrayOutputStream();
5324       System.setOut(new PrintStream(baos));
5325 
5326       GrouperClient
5327           .main(GrouperClientUtils
5328               .splitTrim(
5329                   "--operation=findGroupsWs  --queryFilterType=FIND_BY_GROUP_NAME_APPROXIMATE --groupName=aStem:aGroup --includeGroupDetail=true",
5330                   " "));
5331       System.out.flush();
5332       output = new String(baos.toByteArray());
5333 
5334       System.setOut(systemOut);
5335 
5336       outputLines = GrouperClientUtils.splitTrim(output, "\n");
5337 
5338       matcher = pattern.matcher(outputLines[0]);
5339 
5340       assertEquals(output, 1, outputLines.length);
5341       assertTrue(outputLines[0], matcher.matches());
5342 
5343       assertEquals(output, "0", matcher.group(1));
5344       assertEquals(output, "aStem:aGroup", matcher.group(2));
5345       assertEquals(output, "aStem:aGroup", matcher.group(3));
5346 
5347       assertTrue(GrouperClientWs.mostRecentRequest
5348           .contains("includeGroupDetail"));
5349 
5350       // #####################################################
5351       // run again, with params
5352       baos = new ByteArrayOutputStream();
5353       System.setOut(new PrintStream(baos));
5354 
5355       GrouperClient
5356           .main(GrouperClientUtils
5357               .splitTrim(
5358                   "--operation=findGroupsWs --queryFilterType=FIND_BY_GROUP_NAME_APPROXIMATE --groupName=aStem:aGroup --paramName0=whatever --paramValue0=someValue",
5359                   " "));
5360       System.out.flush();
5361       output = new String(baos.toByteArray());
5362 
5363       System.setOut(systemOut);
5364 
5365       outputLines = GrouperClientUtils.splitTrim(output, "\n");
5366 
5367       matcher = pattern.matcher(outputLines[0]);
5368 
5369       assertEquals(output, 1, outputLines.length);
5370       assertTrue(outputLines[0], matcher.matches());
5371 
5372       assertEquals(output, "0", matcher.group(1));
5373       assertEquals(output, "aStem:aGroup", matcher.group(2));
5374       assertEquals(output, "aStem:aGroup", matcher.group(3));
5375 
5376       assertTrue(GrouperClientWs.mostRecentRequest.contains("whatever")
5377           && GrouperClientWs.mostRecentRequest.contains("someValue"));
5378 
5379       // #####################################################
5380       // run again, with uuid
5381       baos = new ByteArrayOutputStream();
5382       System.setOut(new PrintStream(baos));
5383 
5384       GrouperClient
5385           .main(GrouperClientUtils
5386               .splitTrim(
5387                   "--operation=findGroupsWs --queryFilterType=FIND_BY_GROUP_UUID --groupUuid=abc",
5388                   " "));
5389       System.out.flush();
5390       output = new String(baos.toByteArray());
5391 
5392       System.setOut(systemOut);
5393 
5394       outputLines = GrouperClientUtils.splitTrim(output, "\n");
5395 
5396       assertTrue(output, GrouperClientUtils.isBlank(output));
5397 
5398       assertTrue(GrouperClientWs.mostRecentRequest.contains("groupUuid")
5399           && GrouperClientWs.mostRecentRequest.contains("abc"));
5400 
5401       // #####################################################
5402       // run again, with stem
5403       baos = new ByteArrayOutputStream();
5404       System.setOut(new PrintStream(baos));
5405 
5406       GrouperClient
5407           .main(GrouperClientUtils
5408               .splitTrim(
5409                   "--operation=findGroupsWs --queryFilterType=FIND_BY_GROUP_NAME_APPROXIMATE --groupName=aStem:aGroup --stemName=aStem",
5410                   " "));
5411       System.out.flush();
5412       output = new String(baos.toByteArray());
5413 
5414       System.setOut(systemOut);
5415 
5416       outputLines = GrouperClientUtils.splitTrim(output, "\n");
5417 
5418       matcher = pattern.matcher(outputLines[0]);
5419 
5420       assertEquals(output, 1, outputLines.length);
5421       assertTrue(outputLines[0], matcher.matches());
5422 
5423       assertEquals(output, "0", matcher.group(1));
5424       assertEquals(output, "aStem:aGroup", matcher.group(2));
5425       assertEquals(output, "aStem:aGroup", matcher.group(3));
5426 
5427       assertTrue(GrouperClientWs.mostRecentRequest.contains("stemName")
5428           && GrouperClientWs.mostRecentRequest.contains(">aStem<"));
5429 
5430       // #####################################################
5431       // run again, with group type
5432       baos = new ByteArrayOutputStream();
5433       System.setOut(new PrintStream(baos));
5434 
5435       GrouperClient
5436           .main(GrouperClientUtils
5437               .splitTrim(
5438                   "--operation=findGroupsWs --queryFilterType=FIND_BY_TYPE --groupTypeName=aType",
5439                   " "));
5440       System.out.flush();
5441       output = new String(baos.toByteArray());
5442 
5443       System.setOut(systemOut);
5444 
5445       outputLines = GrouperClientUtils.splitTrim(output, "\n");
5446 
5447       matcher = pattern.matcher(outputLines[0]);
5448 
5449       assertEquals(output, 1, outputLines.length);
5450       assertTrue(outputLines[0], matcher.matches());
5451 
5452       assertEquals(output, "0", matcher.group(1));
5453       assertEquals(output, "aStem:aGroup", matcher.group(2));
5454       assertEquals(output, "aStem:aGroup", matcher.group(3));
5455 
5456       assertTrue(GrouperClientWs.mostRecentRequest.contains("FIND_BY_TYPE")
5457           && GrouperClientWs.mostRecentRequest.contains("groupTypeName")
5458           && GrouperClientWs.mostRecentRequest.contains("aType"));
5459 
5460       // #####################################################
5461       // run again, with group attribute
5462       baos = new ByteArrayOutputStream();
5463       System.setOut(new PrintStream(baos));
5464 
5465       GrouperClient
5466           .main(GrouperClientUtils
5467               .splitTrim(
5468                   "--operation=findGroupsWs --queryFilterType=FIND_BY_EXACT_ATTRIBUTE --groupAttributeName=attr_1 --groupAttributeValue=something",
5469                   " "));
5470       System.out.flush();
5471       output = new String(baos.toByteArray());
5472 
5473       System.setOut(systemOut);
5474 
5475       outputLines = GrouperClientUtils.splitTrim(output, "\n");
5476 
5477       matcher = pattern.matcher(outputLines[0]);
5478 
5479       assertEquals(output, 1, outputLines.length);
5480       assertTrue(outputLines[0], matcher.matches());
5481 
5482       assertEquals(output, "0", matcher.group(1));
5483       assertEquals(output, "aStem:aGroup", matcher.group(2));
5484       assertEquals(output, "aStem:aGroup", matcher.group(3));
5485 
5486       assertTrue(GrouperClientWs.mostRecentRequest
5487           .contains("FIND_BY_EXACT_ATTRIBUTE")
5488           && GrouperClientWs.mostRecentRequest.contains("groupAttributeName")
5489           && GrouperClientWs.mostRecentRequest.contains("attr_1"));
5490 
5491       // #####################################################
5492       // run again, with sub filters
5493       baos = new ByteArrayOutputStream();
5494       System.setOut(new PrintStream(baos));
5495 
5496       GrouperClient
5497           .main(GrouperClientUtils
5498               .splitTrim(
5499                   "--operation=findGroupsWs --queryFilterType=OR --queryFilterType0=OR --queryFilterType00=FIND_BY_GROUP_NAME_APPROXIMATE --groupName00=aStem:aGroup --queryFilterType01=FIND_BY_GROUP_NAME_APPROXIMATE --groupName01=aStem:aGroup --queryFilterType1=FIND_BY_GROUP_NAME_APPROXIMATE --groupName1=aStem:aGroup",
5500                   " "));
5501       System.out.flush();
5502       output = new String(baos.toByteArray());
5503 
5504       System.setOut(systemOut);
5505 
5506       outputLines = GrouperClientUtils.splitTrim(output, "\n");
5507 
5508       matcher = pattern.matcher(outputLines[0]);
5509 
5510       assertEquals(output, 1, outputLines.length);
5511       assertTrue(outputLines[0], matcher.matches());
5512 
5513       assertEquals(output, "0", matcher.group(1));
5514       assertEquals(output, "aStem:aGroup", matcher.group(2));
5515       assertEquals(output, "aStem:aGroup", matcher.group(3));
5516 
5517       assertTrue(GrouperClientWs.mostRecentRequest.contains("OR")
5518           && GrouperClientWs.mostRecentRequest
5519               .contains("FIND_BY_GROUP_NAME_APPROXIMATE"));
5520 
5521       // #####################################################
5522       // run again, search by names
5523 
5524       Group group1 = Group.saveGroup(grouperSession, "aStem:aGroup1", null, "aStem:aGroup1", null, null, null, true);
5525 
5526       baos = new ByteArrayOutputStream();
5527       System.setOut(new PrintStream(baos));
5528 
5529       GrouperClient
5530           .main(GrouperClientUtils
5531               .splitTrim(
5532                   "--operation=findGroupsWs --groupNames=aStem:aGroup,aStem:aGroup1",
5533                   " "));
5534       System.out.flush();
5535       output = new String(baos.toByteArray());
5536 
5537       System.setOut(systemOut);
5538 
5539       outputLines = GrouperClientUtils.splitTrim(output, "\n");
5540 
5541       assertEquals(output, 2, outputLines.length);
5542       matcher = pattern.matcher(outputLines[0]);
5543 
5544       assertTrue(outputLines[0], matcher.matches());
5545 
5546       assertEquals(output, "0", matcher.group(1));
5547       assertEquals(output, "aStem:aGroup", matcher.group(2));
5548       assertEquals(output, "aStem:aGroup", matcher.group(3));
5549 
5550       matcher = pattern.matcher(outputLines[1]);
5551 
5552       assertTrue(outputLines[1], matcher.matches());
5553 
5554       assertEquals(output, "1", matcher.group(1));
5555       assertEquals(output, "aStem:aGroup1", matcher.group(2));
5556       assertEquals(output, "aStem:aGroup1", matcher.group(3));
5557 
5558       // #####################################################
5559       // run again, search by id indexes
5560 
5561       group1 = Group.saveGroup(grouperSession, "aStem:aGroup1", null, "aStem:aGroup1", null, null, null, true);
5562 
5563       baos = new ByteArrayOutputStream();
5564       System.setOut(new PrintStream(baos));
5565 
5566       GrouperClient
5567           .main(GrouperClientUtils
5568               .splitTrim(
5569                   "--operation=findGroupsWs --groupIdIndexes=" + group1.getIdIndex(),
5570                   " "));
5571       System.out.flush();
5572       output = new String(baos.toByteArray());
5573 
5574       System.setOut(systemOut);
5575 
5576       outputLines = GrouperClientUtils.splitTrim(output, "\n");
5577 
5578       assertEquals(output, 1, outputLines.length);
5579       matcher = pattern.matcher(outputLines[0]);
5580 
5581       assertTrue(outputLines[0], matcher.matches());
5582 
5583       assertEquals(output, "0", matcher.group(1));
5584       assertEquals(output, "aStem:aGroup1", matcher.group(2));
5585       assertEquals(output, "aStem:aGroup1", matcher.group(3));
5586 
5587 
5588       // #####################################################
5589       // run again, search by uuids
5590 
5591       baos = new ByteArrayOutputStream();
5592       System.setOut(new PrintStream(baos));
5593 
5594       GrouperClient
5595           .main(GrouperClientUtils
5596               .splitTrim(
5597                   "--operation=findGroupsWs --groupUuids=" + group.getId() + "," + group1.getId(),
5598                   " "));
5599       System.out.flush();
5600       output = new String(baos.toByteArray());
5601 
5602       System.setOut(systemOut);
5603 
5604       outputLines = GrouperClientUtils.splitTrim(output, "\n");
5605 
5606       assertEquals(output, 2, outputLines.length);
5607       matcher = pattern.matcher(outputLines[0]);
5608 
5609       assertTrue(outputLines[0], matcher.matches());
5610 
5611       assertEquals(output, "0", matcher.group(1));
5612       assertEquals(output, "aStem:aGroup", matcher.group(2));
5613       assertEquals(output, "aStem:aGroup", matcher.group(3));
5614 
5615       matcher = pattern.matcher(outputLines[1]);
5616 
5617       assertTrue(outputLines[1], matcher.matches());
5618 
5619       assertEquals(output, "1", matcher.group(1));
5620       assertEquals(output, "aStem:aGroup1", matcher.group(2));
5621       assertEquals(output, "aStem:aGroup1", matcher.group(3));
5622 
5623       // #####################################################
5624       // run again, sort and page
5625 
5626       Group group2 = Group.saveGroup(grouperSession, "aStem:aGroup2", null, "aStem:aGroup2", null, null, null, true);
5627 
5628       baos = new ByteArrayOutputStream();
5629       System.setOut(new PrintStream(baos));
5630 
5631       GrouperClient
5632           .main(GrouperClientUtils
5633               .splitTrim(
5634                   "--operation=findGroupsWs --queryFilterType=FIND_BY_GROUP_NAME_APPROXIMATE --groupName=aStem:a% --stemName=aStem --ascending=T --sortString=name --pageNumber=1 --pageSize=2",
5635                   " "));
5636       System.out.flush();
5637       output = new String(baos.toByteArray());
5638 
5639       System.setOut(systemOut);
5640 
5641       outputLines = GrouperClientUtils.splitTrim(output, "\n");
5642 
5643       assertEquals(output, 2, outputLines.length);
5644       matcher = pattern.matcher(outputLines[0]);
5645 
5646       assertTrue(outputLines[0], matcher.matches());
5647 
5648       assertEquals(output, "0", matcher.group(1));
5649       assertEquals(output, "aStem:aGroup", matcher.group(2));
5650       assertEquals(output, "aStem:aGroup", matcher.group(3));
5651 
5652       matcher = pattern.matcher(outputLines[1]);
5653 
5654       assertTrue(outputLines[1], matcher.matches());
5655 
5656       assertEquals(output, "1", matcher.group(1));
5657       assertEquals(output, "aStem:aGroup1", matcher.group(2));
5658       assertEquals(output, "aStem:aGroup1", matcher.group(3));
5659 
5660       // #####################################################
5661       // run again, sort and page
5662 
5663       baos = new ByteArrayOutputStream();
5664       System.setOut(new PrintStream(baos));
5665 
5666       GrouperClient
5667           .main(GrouperClientUtils
5668               .splitTrim(
5669                   "--operation=findGroupsWs --queryFilterType=FIND_BY_GROUP_NAME_APPROXIMATE --groupName=aStem:a% --stemName=aStem --ascending=T --sortString=name --pageNumber=1 --pageSize=2",
5670                   " "));
5671       System.out.flush();
5672       output = new String(baos.toByteArray());
5673 
5674       System.setOut(systemOut);
5675 
5676       outputLines = GrouperClientUtils.splitTrim(output, "\n");
5677 
5678       assertEquals(output, 2, outputLines.length);
5679       matcher = pattern.matcher(outputLines[0]);
5680 
5681       assertTrue(outputLines[0], matcher.matches());
5682 
5683       assertEquals(output, "0", matcher.group(1));
5684       assertEquals(output, "aStem:aGroup", matcher.group(2));
5685       assertEquals(output, "aStem:aGroup", matcher.group(3));
5686 
5687       matcher = pattern.matcher(outputLines[1]);
5688 
5689       assertTrue(outputLines[1], matcher.matches());
5690 
5691       assertEquals(output, "1", matcher.group(1));
5692       assertEquals(output, "aStem:aGroup1", matcher.group(2));
5693       assertEquals(output, "aStem:aGroup1", matcher.group(3));
5694 
5695 
5696       // #####################################################
5697       // run again, sort and page
5698 
5699       baos = new ByteArrayOutputStream();
5700       System.setOut(new PrintStream(baos));
5701 
5702       GrouperClient
5703           .main(GrouperClientUtils
5704               .splitTrim(
5705                   "--operation=findGroupsWs --queryFilterType=FIND_BY_STEM_NAME --stemName=aStem --ascending=T --sortString=name --pageNumber=2 --pageSize=2",
5706                   " "));
5707       System.out.flush();
5708       output = new String(baos.toByteArray());
5709 
5710       System.setOut(systemOut);
5711 
5712       outputLines = GrouperClientUtils.splitTrim(output, "\n");
5713 
5714       assertEquals(output, 1, outputLines.length);
5715       matcher = pattern.matcher(outputLines[0]);
5716 
5717       assertTrue(outputLines[0], matcher.matches());
5718 
5719       assertEquals(output, "0", matcher.group(1));
5720       assertEquals(output, "aStem:aGroup2", matcher.group(2));
5721       assertEquals(output, "aStem:aGroup2", matcher.group(3));
5722 
5723       // #####################################################
5724       // run again, with typeOfGroup = group
5725       baos = new ByteArrayOutputStream();
5726       System.setOut(new PrintStream(baos));
5727 
5728       GrouperClient
5729           .main(GrouperClientUtils
5730               .splitTrim(
5731                   "--operation=findGroupsWs --queryFilterType=FIND_BY_GROUP_NAME_APPROXIMATE --groupName=aStem:aGroup --stemName=aStem --typeOfGroups=group",
5732                   " "));
5733       System.out.flush();
5734       output = new String(baos.toByteArray());
5735 
5736       System.setOut(systemOut);
5737 
5738       outputLines = GrouperClientUtils.splitTrim(output, "\n");
5739 
5740       matcher = pattern.matcher(outputLines[0]);
5741 
5742       assertEquals(output, 3, outputLines.length);
5743       assertTrue(outputLines[0], matcher.matches());
5744 
5745       assertEquals(output, "0", matcher.group(1));
5746       assertEquals(output, "aStem:aGroup", matcher.group(2));
5747       assertEquals(output, "aStem:aGroup", matcher.group(3));
5748 
5749       matcher = pattern.matcher(outputLines[1]);
5750       assertTrue(outputLines[1], matcher.matches());
5751 
5752       assertEquals(output, "1", matcher.group(1));
5753       assertEquals(output, "aStem:aGroup1", matcher.group(2));
5754       assertEquals(output, "aStem:aGroup1", matcher.group(3));
5755 
5756       matcher = pattern.matcher(outputLines[2]);
5757       assertTrue(outputLines[2], matcher.matches());
5758 
5759       assertEquals(output, "2", matcher.group(1));
5760       assertEquals(output, "aStem:aGroup2", matcher.group(2));
5761       assertEquals(output, "aStem:aGroup2", matcher.group(3));
5762 
5763       assertTrue(GrouperClientWs.mostRecentRequest.contains("typeOfGroups")
5764           && GrouperClientWs.mostRecentRequest.contains(">group<"));
5765 
5766       // #####################################################
5767       // run again, with typeOfGroup = role
5768       baos = new ByteArrayOutputStream();
5769       System.setOut(new PrintStream(baos));
5770 
5771       GrouperClient
5772           .main(GrouperClientUtils
5773               .splitTrim(
5774                   "--operation=findGroupsWs --queryFilterType=FIND_BY_GROUP_NAME_APPROXIMATE --groupName=aStem:aGroup --stemName=aStem --typeOfGroups=role",
5775                   " "));
5776       System.out.flush();
5777       output = new String(baos.toByteArray());
5778 
5779       System.setOut(systemOut);
5780 
5781       outputLines = GrouperClientUtils.splitTrim(output, "\n");
5782 
5783       assertEquals(output, 0, GrouperUtil.length(outputLines));
5784 
5785       assertTrue(GrouperClientWs.mostRecentRequest.contains("typeOfGroups")
5786           && GrouperClientWs.mostRecentRequest.contains(">role<"));
5787 
5788 
5789 
5790     } finally {
5791       System.setOut(systemOut);
5792     }
5793 
5794   }
5795 
5796   /**
5797    * @throws Exception
5798    */
5799   public void testFindStems() throws Exception {
5800 
5801     PrintStream systemOut = System.out;
5802 
5803     ByteArrayOutputStream baos = new ByteArrayOutputStream();
5804     System.setOut(new PrintStream(baos));
5805 
5806     try {
5807 
5808       GrouperClient
5809           .main(GrouperClientUtils
5810               .splitTrim(
5811                   "--operation=findStemsWs --stemQueryFilterType=FIND_BY_STEM_NAME --stemName=aStem",
5812                   " "));
5813       System.out.flush();
5814       String output = new String(baos.toByteArray());
5815 
5816       System.setOut(systemOut);
5817 
5818       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
5819 
5820       Pattern pattern = Pattern
5821           .compile("^Index (\\d+): name: (.+), displayName: (.+)$");
5822       Matcher matcher = pattern.matcher(outputLines[0]);
5823 
5824       assertEquals(output, 1, outputLines.length);
5825       assertTrue(outputLines[0], matcher.matches());
5826 
5827       assertEquals(output, "0", matcher.group(1));
5828       assertEquals(output, "aStem", matcher.group(2));
5829       assertEquals(output, "aStem", matcher.group(3));
5830 
5831       // #####################################################
5832       // run with invalid args
5833       baos = new ByteArrayOutputStream();
5834       System.setOut(new PrintStream(baos));
5835 
5836       // test a command line template
5837       try {
5838         GrouperClient
5839             .main(GrouperClientUtils
5840                 .splitTrim(
5841                     "--operation=findStemsWs --stemQueryFilterType=FIND_BY_STEM_NAME --groupName=aStem:aGroup --ousdfsdfate=${index}",
5842                     " "));
5843       } catch (Exception e) {
5844         assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
5845       }
5846       System.out.flush();
5847 
5848       System.setOut(systemOut);
5849 
5850       // #####################################################
5851       // run with custom template
5852       baos = new ByteArrayOutputStream();
5853       System.setOut(new PrintStream(baos));
5854 
5855       // test a command line template
5856       GrouperClient
5857           .main(GrouperClientUtils
5858               .splitTrim(
5859                   "--operation=findStemsWs --stemQueryFilterType=FIND_BY_STEM_NAME --stemName=aStem --outputTemplate=${index}",
5860                   " "));
5861 
5862       System.out.flush();
5863 
5864       output = new String(baos.toByteArray());
5865 
5866       System.setOut(systemOut);
5867 
5868       assertEquals("0", output);
5869 
5870       // #####################################################
5871       // run again, with parentStemScope
5872       baos = new ByteArrayOutputStream();
5873       System.setOut(new PrintStream(baos));
5874 
5875       GrouperClient
5876           .main(GrouperClientUtils
5877               .splitTrim(
5878                   "--operation=findStemsWs  --stemQueryFilterType=FIND_BY_PARENT_STEM_NAME --parentStemName=aStem --parentStemNameScope=ALL_IN_SUBTREE",
5879                   " "));
5880       System.out.flush();
5881       output = new String(baos.toByteArray());
5882 
5883       System.setOut(systemOut);
5884 
5885       outputLines = GrouperClientUtils.splitTrim(output, "\n");
5886 
5887       matcher = pattern.matcher(outputLines[0]);
5888 
5889       assertEquals(output, 1, outputLines.length);
5890       assertTrue(outputLines[0], matcher.matches());
5891 
5892       assertEquals(output, "0", matcher.group(1));
5893       assertEquals(output, "aStem:aStem0", matcher.group(2));
5894       assertEquals(output, "aStem:aStem0", matcher.group(3));
5895 
5896       assertTrue(GrouperClientWs.mostRecentRequest,
5897           GrouperClientWs.mostRecentRequest.contains("parentStemName")
5898               && GrouperClientWs.mostRecentRequest
5899                   .contains("parentStemNameScope"));
5900 
5901       // #####################################################
5902       // run again, with params
5903       baos = new ByteArrayOutputStream();
5904       System.setOut(new PrintStream(baos));
5905 
5906       GrouperClient
5907           .main(GrouperClientUtils
5908               .splitTrim(
5909                   "--operation=findStemsWs --stemQueryFilterType=FIND_BY_STEM_NAME --stemName=aStem --paramName0=whatever --paramValue0=someValue",
5910                   " "));
5911       System.out.flush();
5912       output = new String(baos.toByteArray());
5913 
5914       System.setOut(systemOut);
5915 
5916       outputLines = GrouperClientUtils.splitTrim(output, "\n");
5917 
5918       matcher = pattern.matcher(outputLines[0]);
5919 
5920       assertEquals(output, 1, outputLines.length);
5921       assertTrue(outputLines[0], matcher.matches());
5922 
5923       assertEquals(output, "0", matcher.group(1));
5924       assertEquals(output, "aStem", matcher.group(2));
5925       assertEquals(output, "aStem", matcher.group(3));
5926 
5927       assertTrue(GrouperClientWs.mostRecentRequest.contains("whatever")
5928           && GrouperClientWs.mostRecentRequest.contains("someValue"));
5929 
5930       // #####################################################
5931       // run again, with uuid
5932       baos = new ByteArrayOutputStream();
5933       System.setOut(new PrintStream(baos));
5934 
5935       GrouperClient
5936           .main(GrouperClientUtils
5937               .splitTrim(
5938                   "--operation=findStemsWs --stemQueryFilterType=FIND_BY_STEM_UUID --stemUuid=abc",
5939                   " "));
5940       System.out.flush();
5941       output = new String(baos.toByteArray());
5942 
5943       System.setOut(systemOut);
5944 
5945       outputLines = GrouperClientUtils.splitTrim(output, "\n");
5946 
5947       assertTrue(output, GrouperClientUtils.isBlank(output));
5948 
5949       assertTrue(GrouperClientWs.mostRecentRequest.contains("stemUuid")
5950           && GrouperClientWs.mostRecentRequest.contains("abc"));
5951 
5952       // #####################################################
5953       // run again, with stem attribute
5954       baos = new ByteArrayOutputStream();
5955       System.setOut(new PrintStream(baos));
5956 
5957       GrouperClient
5958           .main(GrouperClientUtils
5959               .splitTrim(
5960                   "--operation=findStemsWs --stemQueryFilterType=FIND_BY_APPROXIMATE_ATTRIBUTE --stemAttributeName=name --stemAttributeValue=aStem",
5961                   " "));
5962       System.out.flush();
5963       output = new String(baos.toByteArray());
5964 
5965       System.setOut(systemOut);
5966 
5967       outputLines = GrouperClientUtils.splitTrim(output, "\n");
5968 
5969       matcher = pattern.matcher(outputLines[0]);
5970 
5971       assertEquals(output, 2, outputLines.length);
5972       assertTrue(outputLines[0], matcher.matches());
5973 
5974       assertEquals(output, "0", matcher.group(1));
5975       assertEquals(output, "aStem", matcher.group(2));
5976       assertEquals(output, "aStem", matcher.group(3));
5977 
5978       matcher = pattern.matcher(outputLines[1]);
5979       assertTrue(outputLines[1], matcher.matches());
5980 
5981       assertEquals(output, "1", matcher.group(1));
5982       assertEquals(output, "aStem:aStem0", matcher.group(2));
5983       assertEquals(output, "aStem:aStem0", matcher.group(3));
5984 
5985       assertTrue(GrouperClientWs.mostRecentRequest
5986           .contains("FIND_BY_APPROXIMATE_ATTRIBUTE")
5987           && GrouperClientWs.mostRecentRequest.contains("stemAttributeName")
5988           && GrouperClientWs.mostRecentRequest.contains("aStem"));
5989 
5990       // #####################################################
5991       // run again, with sub filters
5992       baos = new ByteArrayOutputStream();
5993       System.setOut(new PrintStream(baos));
5994 
5995       GrouperClient
5996           .main(GrouperClientUtils
5997               .splitTrim(
5998                   "--operation=findStemsWs --stemQueryFilterType=OR --stemQueryFilterType0=OR --stemQueryFilterType00=FIND_BY_STEM_NAME --stemName00=aStem --stemQueryFilterType01=FIND_BY_STEM_NAME --stemName01=aStem --stemQueryFilterType1=FIND_BY_STEM_NAME --stemName1=aStem",
5999                   " "));
6000       System.out.flush();
6001       output = new String(baos.toByteArray());
6002 
6003       System.setOut(systemOut);
6004 
6005       outputLines = GrouperClientUtils.splitTrim(output, "\n");
6006 
6007       matcher = pattern.matcher(outputLines[0]);
6008 
6009       assertEquals(output, 1, outputLines.length);
6010       assertTrue(outputLines[0], matcher.matches());
6011 
6012       assertEquals(output, "0", matcher.group(1));
6013       assertEquals(output, "aStem", matcher.group(2));
6014       assertEquals(output, "aStem", matcher.group(3));
6015 
6016       assertTrue(GrouperClientWs.mostRecentRequest.contains("OR")
6017           && GrouperClientWs.mostRecentRequest.contains("FIND_BY_STEM_NAME"));
6018 
6019       // #####################################################
6020       // run again, search by names
6021       GrouperSession grouperSession = GrouperSession.startRootSession();
6022       Stem aStem = StemFinder.findByName(grouperSession, "aStem", true);
6023       Stem aStem0 = StemFinder.findByName(grouperSession, "aStem:aStem0", true);
6024 
6025       baos = new ByteArrayOutputStream();
6026       System.setOut(new PrintStream(baos));
6027 
6028       GrouperClient
6029           .main(GrouperClientUtils
6030               .splitTrim(
6031                   "--operation=findStemsWs --stemNames=aStem,aStem:aStem0",
6032                   " "));
6033       System.out.flush();
6034       output = new String(baos.toByteArray());
6035 
6036       System.setOut(systemOut);
6037 
6038       outputLines = GrouperClientUtils.splitTrim(output, "\n");
6039 
6040       assertEquals(output, 2, outputLines.length);
6041       matcher = pattern.matcher(outputLines[0]);
6042 
6043       assertTrue(outputLines[0], matcher.matches());
6044 
6045       assertEquals(output, "0", matcher.group(1));
6046       assertEquals(output, "aStem", matcher.group(2));
6047       assertEquals(output, "aStem", matcher.group(3));
6048 
6049       matcher = pattern.matcher(outputLines[1]);
6050 
6051       assertTrue(outputLines[1], matcher.matches());
6052 
6053       assertEquals(output, "1", matcher.group(1));
6054       assertEquals(output, "aStem:aStem0", matcher.group(2));
6055       assertEquals(output, "aStem:aStem0", matcher.group(3));
6056 
6057       // #####################################################
6058       // run again, search by id indexes
6059 
6060       baos = new ByteArrayOutputStream();
6061       System.setOut(new PrintStream(baos));
6062 
6063       GrouperClient
6064           .main(GrouperClientUtils
6065               .splitTrim(
6066                   "--operation=findStemsWs --stemIdIndexes=" + aStem.getIdIndex(),
6067                   " "));
6068       System.out.flush();
6069       output = new String(baos.toByteArray());
6070 
6071       System.setOut(systemOut);
6072 
6073       outputLines = GrouperClientUtils.splitTrim(output, "\n");
6074 
6075       assertEquals(output, 1, outputLines.length);
6076       matcher = pattern.matcher(outputLines[0]);
6077 
6078       assertTrue(outputLines[0], matcher.matches());
6079 
6080       assertEquals(output, "0", matcher.group(1));
6081       assertEquals(output, "aStem", matcher.group(2));
6082       assertEquals(output, "aStem", matcher.group(3));
6083 
6084       // #####################################################
6085       // run again, search by uuids
6086 
6087       baos = new ByteArrayOutputStream();
6088       System.setOut(new PrintStream(baos));
6089 
6090       GrouperClient
6091           .main(GrouperClientUtils
6092               .splitTrim(
6093                   "--operation=findStemsWs --stemUuids=" + aStem.getUuid() + "," + aStem0.getUuid(),
6094                   " "));
6095       System.out.flush();
6096       output = new String(baos.toByteArray());
6097 
6098       System.setOut(systemOut);
6099 
6100       outputLines = GrouperClientUtils.splitTrim(output, "\n");
6101 
6102       assertEquals(output, 2, outputLines.length);
6103       matcher = pattern.matcher(outputLines[0]);
6104 
6105       assertTrue(outputLines[0], matcher.matches());
6106 
6107       assertEquals(output, "0", matcher.group(1));
6108       assertEquals(output, "aStem", matcher.group(2));
6109       assertEquals(output, "aStem", matcher.group(3));
6110 
6111       matcher = pattern.matcher(outputLines[1]);
6112 
6113       assertTrue(outputLines[1], matcher.matches());
6114 
6115       assertEquals(output, "1", matcher.group(1));
6116       assertEquals(output, "aStem:aStem0", matcher.group(2));
6117       assertEquals(output, "aStem:aStem0", matcher.group(3));
6118 
6119       // #####################################################
6120       // run again, sort and page
6121 
6122       new StemSave(grouperSession).assignName("aStem:aStem1").save();
6123       new StemSave(grouperSession).assignName("aStem:aStem2").save();
6124 
6125 
6126       baos = new ByteArrayOutputStream();
6127       System.setOut(new PrintStream(baos));
6128 
6129       GrouperClient
6130           .main(GrouperClientUtils
6131               .splitTrim(
6132                   "--operation=findStemsWs --stemQueryFilterType=FIND_BY_STEM_NAME_APPROXIMATE --stemName=aStem:a% --parentStemName=aStem  --ascending=T --sortString=name --pageNumber=1 --pageSize=2",
6133                   " "));
6134       System.out.flush();
6135       output = new String(baos.toByteArray());
6136 
6137       System.setOut(systemOut);
6138 
6139       outputLines = GrouperClientUtils.splitTrim(output, "\n");
6140 
6141       assertEquals(output, 2, outputLines.length);
6142       matcher = pattern.matcher(outputLines[0]);
6143 
6144       assertTrue(outputLines[0], matcher.matches());
6145 
6146       assertEquals(output, "0", matcher.group(1));
6147       assertEquals(output, "aStem:aStem0", matcher.group(2));
6148 
6149       matcher = pattern.matcher(outputLines[1]);
6150 
6151       assertTrue(outputLines[1], matcher.matches());
6152 
6153       assertEquals(output, "1", matcher.group(1));
6154       assertEquals(output, "aStem:aStem1", matcher.group(2));
6155 
6156 
6157       // #####################################################
6158       // run again, sort and page
6159 
6160       new StemSave(grouperSession).assignName("aStem:aStem1").save();
6161       new StemSave(grouperSession).assignName("aStem:aStem2").save();
6162 
6163 
6164       baos = new ByteArrayOutputStream();
6165       System.setOut(new PrintStream(baos));
6166 
6167       GrouperClient
6168           .main(GrouperClientUtils
6169               .splitTrim(
6170                   "--operation=findStemsWs --stemQueryFilterType=FIND_BY_PARENT_STEM_NAME --parentStemName=aStem  --ascending=T --sortString=name --pageNumber=2 --pageSize=2",
6171                   " "));
6172       System.out.flush();
6173       output = new String(baos.toByteArray());
6174 
6175       System.setOut(systemOut);
6176 
6177       outputLines = GrouperClientUtils.splitTrim(output, "\n");
6178 
6179       assertEquals(output, 1, outputLines.length);
6180       matcher = pattern.matcher(outputLines[0]);
6181 
6182       assertTrue(outputLines[0], matcher.matches());
6183 
6184       assertEquals(output, "0", matcher.group(1));
6185       assertEquals(output, "aStem:aStem2", matcher.group(2));
6186 
6187 
6188 
6189     } finally {
6190       System.setOut(systemOut);
6191     }
6192 
6193   }
6194 
6195   /**
6196    * try get members with a slash
6197    * Note: for this test to work, you need this in tomcat start:
6198    * -Dorg.apache.tomcat.util.buf.UDecoder.ALLOW_ENCODED_SLASH=true
6199    * @throws Exception
6200    */
6201   public void testGetMembersSlash() throws Exception {
6202     // make sure group exists
6203     GrouperSession grouperSession = GrouperSession.startRootSession();
6204     Group group = Group.saveGroup(grouperSession, "aStem:aGroup/1", null,
6205         "aStem:aGroup/1", "aGroup", null, null, true);
6206 
6207     // give permissions
6208     String wsUserLabel = GrouperClientUtils.propertiesValue(
6209         "grouperClient.webService.user.label", true);
6210     String wsUserString = GrouperClientUtils.propertiesValue(
6211         "grouperClient.webService." + wsUserLabel, true);
6212     Subject wsUser = SubjectFinder.findByIdOrIdentifier(wsUserString, true);
6213 
6214     group.grantPriv(wsUser, AccessPrivilege.READ, false);
6215     group.grantPriv(wsUser, AccessPrivilege.VIEW, false);
6216     group.grantPriv(wsUser, AccessPrivilege.ADMIN, false);
6217 
6218     // add some subjects
6219     //group.addMember(SubjectTestHelper.SUBJ0, false);
6220 
6221     PrintStream systemOut = System.out;
6222 
6223     ByteArrayOutputStream baos = new ByteArrayOutputStream();
6224     System.setOut(new PrintStream(baos));
6225 
6226     try {
6227 
6228       //add member
6229 
6230       GrouperClient.main(GrouperClientUtils.splitTrim(
6231               "--operation=addMemberWs --groupName=aStem:aGroup/1 --subjectIds=test.subject.0 --outputTemplate=Index${index}:success:${resultMetadata.success}:code:${resultMetadata.resultCode}:${wsSubject.id}:${wsAddMemberResults.wsGroupAssigned.name}$newline$${index}",
6232               " "));
6233       System.out.flush();
6234       String output = new String(baos.toByteArray());
6235 
6236       System.setOut(systemOut);
6237 
6238       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
6239 
6240       //match this: Index0:success:T:code:SUCCESS:test.subject.0:aStem:aGroup/1
6241       Pattern pattern = Pattern
6242           .compile("^Index(\\d+):success:T:code:([A-Z_]+?):(.+?):(.*+)$");
6243       Matcher matcher = pattern.matcher(outputLines[0]);
6244 
6245       assertTrue(outputLines[0], matcher.matches());
6246 
6247       assertEquals(outputLines[0], "0", matcher.group(1));
6248       assertEquals(outputLines[0], "SUCCESS", matcher.group(2));
6249       assertEquals(outputLines[0], "test.subject.0", matcher.group(3));
6250       assertEquals(outputLines[0], "aStem:aGroup/1", matcher.group(4));
6251 
6252 
6253       //get members
6254       baos = new ByteArrayOutputStream();
6255       System.setOut(new PrintStream(baos));
6256 
6257       GrouperClient.main(GrouperClientUtils.splitTrim(
6258           "--operation=getMembersWs --groupNames=aStem:aGroup/1",
6259           " "));
6260       System.out.flush();
6261       output = new String(baos.toByteArray());
6262 
6263       System.setOut(systemOut);
6264 
6265       outputLines = GrouperClientUtils.splitTrim(output, "\n");
6266 
6267       // match: ^GroupIndex (\d+)\: success\: ([TF])\: code: ([A-Z_]+)\: group\:
6268       // (.*)\: subjectIndex\: (\d+)\: (.*)$
6269       pattern = Pattern
6270           .compile("^GroupIndex (\\d+)\\: success\\: ([TF])\\: code: ([A-Z_]+)\\: group\\: (.*)\\: subjectIndex\\: (\\d+)\\: (.*)$");
6271       matcher = pattern.matcher(outputLines[0]);
6272 
6273       assertTrue(outputLines[0], matcher.matches());
6274 
6275       assertEquals(outputLines[0], "0", matcher.group(1));
6276       assertEquals(outputLines[0], "T", matcher.group(2));
6277       assertEquals(outputLines[0], "SUCCESS", matcher.group(3));
6278       assertEquals(outputLines[0], "aStem:aGroup/1", matcher.group(4));
6279       assertEquals(outputLines[0], "0", matcher.group(5));
6280       String subjectId = matcher.group(6);
6281       assertTrue(outputLines[0], GrouperClientUtils.equals("test.subject.0",
6282           subjectId));
6283     } finally {
6284       System.setOut(systemOut);
6285     }
6286   }
6287 
6288   /**
6289    * @throws Exception
6290    */
6291   public void testGetMembers() throws Exception {
6292 
6293     // make sure group exists
6294     GrouperSession grouperSession = GrouperSession.startRootSession();
6295     Group group = Group.saveGroup(grouperSession, "aStem:aGroup", null,
6296         "aStem:aGroup", "aGroup", null, null, true);
6297     Group group2 = Group.saveGroup(grouperSession, "aStem:aGroup2", null,
6298         "aStem:aGroup2", "aGroup2", null, null, true);
6299 
6300     // give permissions
6301     String wsUserLabel = GrouperClientUtils.propertiesValue(
6302         "grouperClient.webService.user.label", true);
6303     String wsUserString = GrouperClientUtils.propertiesValue(
6304         "grouperClient.webService." + wsUserLabel, true);
6305     Subject wsUser = SubjectFinder.findByIdOrIdentifier(wsUserString, true);
6306 
6307     group.grantPriv(wsUser, AccessPrivilege.READ, false);
6308     group.grantPriv(wsUser, AccessPrivilege.VIEW, false);
6309     group2.grantPriv(wsUser, AccessPrivilege.READ, false);
6310     group2.grantPriv(wsUser, AccessPrivilege.VIEW, false);
6311 
6312     // add some subjects for PIT
6313     group.addMember(SubjectTestHelper.SUBJ4, false);
6314     group.deleteMember(SubjectTestHelper.SUBJ4, false);
6315     Thread.sleep(100);
6316     Timestamp pointInTimeFrom = new Timestamp(new Date().getTime());
6317     Thread.sleep(100);
6318 
6319     group.addMember(SubjectTestHelper.SUBJ5, false);
6320     group.deleteMember(SubjectTestHelper.SUBJ5, false);
6321 
6322     // add some subjects
6323     group.addMember(SubjectTestHelper.SUBJ0, false);
6324     group.addMember(SubjectTestHelper.SUBJ1, false);
6325     group2.addMember(SubjectTestHelper.SUBJ2, false);
6326     group2.addMember(SubjectTestHelper.SUBJ3, false);
6327 
6328     // add some subjects for PIT
6329     group.addMember(SubjectTestHelper.SUBJ6, false);
6330     group.deleteMember(SubjectTestHelper.SUBJ6, false);
6331     Thread.sleep(100);
6332     Timestamp pointInTimeTo = new Timestamp(new Date().getTime());
6333     Thread.sleep(100);
6334 
6335     group.addMember(SubjectTestHelper.SUBJ7, false);
6336     group.deleteMember(SubjectTestHelper.SUBJ7, false);
6337     ChangeLogTempToEntity.convertRecords();
6338 
6339     PrintStream systemOut = System.out;
6340 
6341     ByteArrayOutputStream baos = new ByteArrayOutputStream();
6342     System.setOut(new PrintStream(baos));
6343 
6344     try {
6345 
6346       GrouperClient.main(GrouperClientUtils.splitTrim(
6347           "--operation=getMembersWs --groupNames=aStem:aGroup,aStem:aGroup2",
6348           " "));
6349       System.out.flush();
6350       String output = new String(baos.toByteArray());
6351 
6352       System.setOut(systemOut);
6353 
6354       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
6355 
6356       // match: ^GroupIndex (\d+)\: success\: ([TF])\: code: ([A-Z_]+)\: group\:
6357       // (.*)\: subjectIndex\: (\d+)\: (.*)$
6358       Pattern pattern = Pattern
6359           .compile("^GroupIndex (\\d+)\\: success\\: ([TF])\\: code: ([A-Z_]+)\\: group\\: (.*)\\: subjectIndex\\: (\\d+)\\: (.*)$");
6360       Matcher matcher = pattern.matcher(outputLines[0]);
6361 
6362       assertTrue(outputLines[0], matcher.matches());
6363 
6364       assertEquals(outputLines[0], "0", matcher.group(1));
6365       assertEquals(outputLines[0], "T", matcher.group(2));
6366       assertEquals(outputLines[0], "SUCCESS", matcher.group(3));
6367       assertEquals(outputLines[0], "aStem:aGroup", matcher.group(4));
6368       assertEquals(outputLines[0], "0", matcher.group(5));
6369       String subjectId = matcher.group(6);
6370       assertTrue(outputLines[0], GrouperClientUtils.equals("test.subject.0",
6371           subjectId)
6372           || GrouperClientUtils.equals("test.subject.1", subjectId));
6373 
6374       matcher = pattern.matcher(outputLines[1]);
6375 
6376       assertTrue(outputLines[1], matcher.matches());
6377 
6378       assertEquals(outputLines[1], "0", matcher.group(1));
6379       assertEquals(outputLines[1], "T", matcher.group(2));
6380       assertEquals(outputLines[1], "SUCCESS", matcher.group(3));
6381       assertEquals(outputLines[1], "aStem:aGroup", matcher.group(4));
6382       assertEquals(outputLines[1], "1", matcher.group(5));
6383       subjectId = matcher.group(6);
6384       assertTrue(outputLines[1], GrouperClientUtils.equals("test.subject.0",
6385           subjectId)
6386           || GrouperClientUtils.equals("test.subject.1", subjectId));
6387 
6388       matcher = pattern.matcher(outputLines[2]);
6389 
6390       assertTrue(outputLines[2], matcher.matches());
6391 
6392       assertEquals(outputLines[2], "1", matcher.group(1));
6393       assertEquals(outputLines[2], "T", matcher.group(2));
6394       assertEquals(outputLines[2], "SUCCESS", matcher.group(3));
6395       assertEquals(outputLines[2], "aStem:aGroup2", matcher.group(4));
6396       assertEquals(outputLines[2], "0", matcher.group(5));
6397       subjectId = matcher.group(6);
6398       assertTrue(outputLines[2], GrouperClientUtils.equals("test.subject.2",
6399           subjectId)
6400           || GrouperClientUtils.equals("test.subject.3", subjectId));
6401 
6402       matcher = pattern.matcher(outputLines[3]);
6403 
6404       assertTrue(outputLines[3], matcher.matches());
6405 
6406       assertEquals(outputLines[3], "1", matcher.group(1));
6407       assertEquals(outputLines[3], "T", matcher.group(2));
6408       assertEquals(outputLines[3], "SUCCESS", matcher.group(3));
6409       assertEquals(outputLines[3], "aStem:aGroup2", matcher.group(4));
6410       assertEquals(outputLines[3], "1", matcher.group(5));
6411       subjectId = matcher.group(6);
6412       assertTrue(outputLines[3], GrouperClientUtils.equals("test.subject.2",
6413           subjectId)
6414           || GrouperClientUtils.equals("test.subject.3", subjectId));
6415 
6416       assertTrue(GrouperClientWs.mostRecentRequest,
6417           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
6418       assertTrue(GrouperClientWs.mostRecentRequest,
6419           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
6420       assertTrue(GrouperClientWs.mostRecentRequest,
6421           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
6422       assertTrue(GrouperClientWs.mostRecentRequest,
6423           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
6424       assertTrue(GrouperClientWs.mostRecentRequest,
6425           !GrouperClientWs.mostRecentRequest.contains("params"));
6426       assertTrue(GrouperClientWs.mostRecentRequest,
6427           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
6428       assertTrue(GrouperClientWs.mostRecentRequest,
6429           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
6430       assertTrue(GrouperClientWs.mostRecentRequest,
6431           !GrouperClientWs.mostRecentRequest.contains("pageSize"));
6432       assertTrue(GrouperClientWs.mostRecentRequest,
6433           !GrouperClientWs.mostRecentRequest.contains("pageNumber"));
6434       assertTrue(GrouperClientWs.mostRecentRequest,
6435           !GrouperClientWs.mostRecentRequest.contains("sortString"));
6436       assertTrue(GrouperClientWs.mostRecentRequest,
6437           !GrouperClientWs.mostRecentRequest.contains("ascending"));
6438 
6439       // ######################################################
6440       // Try sorting, paging
6441 
6442       baos = new ByteArrayOutputStream();
6443       System.setOut(new PrintStream(baos));
6444 
6445       ArrayList<String> args = new ArrayList<String>();
6446       args.add("--operation=getMembersWs");
6447       args.add("--groupNames=aStem:aGroup");
6448       args.add("--pageSize=1");
6449       args.add("--pageNumber=2");
6450       args.add("--sortString=subjectId");
6451       args.add("--ascending=true");
6452       GrouperClient.main(args.toArray(new String[0]));
6453 
6454       System.out.flush();
6455       output = new String(baos.toByteArray());
6456       System.setOut(systemOut);
6457 
6458       outputLines = GrouperClientUtils.splitTrim(output, "\n");
6459 
6460       assertEquals(1, outputLines.length);
6461 
6462       matcher = pattern.matcher(outputLines[0]);
6463 
6464       assertTrue(outputLines[0], matcher.matches());
6465 
6466       assertEquals(outputLines[0], "0", matcher.group(1));
6467       assertEquals(outputLines[0], "T", matcher.group(2));
6468       assertEquals(outputLines[0], "SUCCESS", matcher.group(3));
6469       assertEquals(outputLines[0], "aStem:aGroup", matcher.group(4));
6470       assertEquals(outputLines[0], "0", matcher.group(5));
6471       subjectId = matcher.group(6);
6472       assertTrue(outputLines[0], GrouperClientUtils.equals("test.subject.1",
6473           subjectId));
6474 
6475 
6476       assertTrue(GrouperClientWs.mostRecentRequest,
6477           GrouperClientWs.mostRecentRequest.contains("pageSize"));
6478       assertTrue(GrouperClientWs.mostRecentRequest,
6479           GrouperClientWs.mostRecentRequest.contains("pageNumber"));
6480       assertTrue(GrouperClientWs.mostRecentRequest,
6481           GrouperClientWs.mostRecentRequest.contains("sortString"));
6482       assertTrue(GrouperClientWs.mostRecentRequest,
6483           GrouperClientWs.mostRecentRequest.contains("ascending"));
6484 
6485 
6486       // ######################################################
6487       // Try point in time
6488 
6489       baos = new ByteArrayOutputStream();
6490       System.setOut(new PrintStream(baos));
6491 
6492       args = new ArrayList<String>();
6493       args.add("--operation=getMembersWs");
6494       args.add("--groupNames=aStem:aGroup,aStem:aGroup2");
6495       args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTimeFrom));
6496       args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTimeTo));
6497       GrouperClient.main(args.toArray(new String[0]));
6498 
6499       System.out.flush();
6500       output = new String(baos.toByteArray());
6501       System.setOut(systemOut);
6502 
6503       outputLines = GrouperClientUtils.splitTrim(output, "\n");
6504 
6505       matcher = pattern.matcher(outputLines[0]);
6506 
6507       assertTrue(outputLines[0], matcher.matches());
6508 
6509       assertEquals(outputLines[0], "0", matcher.group(1));
6510       assertEquals(outputLines[0], "T", matcher.group(2));
6511       assertEquals(outputLines[0], "SUCCESS", matcher.group(3));
6512       assertEquals(outputLines[0], "aStem:aGroup", matcher.group(4));
6513       assertEquals(outputLines[0], "0", matcher.group(5));
6514       subjectId = matcher.group(6);
6515       assertTrue(outputLines[0], GrouperClientUtils.equals("test.subject.0", subjectId) ||
6516           GrouperClientUtils.equals("test.subject.1", subjectId) ||
6517           GrouperClientUtils.equals("test.subject.5", subjectId) ||
6518           GrouperClientUtils.equals("test.subject.6", subjectId));
6519 
6520       matcher = pattern.matcher(outputLines[1]);
6521 
6522       assertTrue(outputLines[1], matcher.matches());
6523 
6524       assertEquals(outputLines[1], "0", matcher.group(1));
6525       assertEquals(outputLines[1], "T", matcher.group(2));
6526       assertEquals(outputLines[1], "SUCCESS", matcher.group(3));
6527       assertEquals(outputLines[1], "aStem:aGroup", matcher.group(4));
6528       assertEquals(outputLines[1], "1", matcher.group(5));
6529       subjectId = matcher.group(6);
6530       assertTrue(outputLines[1], GrouperClientUtils.equals("test.subject.0", subjectId) ||
6531           GrouperClientUtils.equals("test.subject.1", subjectId) ||
6532           GrouperClientUtils.equals("test.subject.5", subjectId) ||
6533           GrouperClientUtils.equals("test.subject.6", subjectId));
6534 
6535       matcher = pattern.matcher(outputLines[2]);
6536 
6537       assertTrue(outputLines[2], matcher.matches());
6538 
6539       assertEquals(outputLines[2], "0", matcher.group(1));
6540       assertEquals(outputLines[2], "T", matcher.group(2));
6541       assertEquals(outputLines[2], "SUCCESS", matcher.group(3));
6542       assertEquals(outputLines[2], "aStem:aGroup", matcher.group(4));
6543       assertEquals(outputLines[2], "2", matcher.group(5));
6544       subjectId = matcher.group(6);
6545       assertTrue(outputLines[2], GrouperClientUtils.equals("test.subject.0", subjectId) ||
6546           GrouperClientUtils.equals("test.subject.1", subjectId) ||
6547           GrouperClientUtils.equals("test.subject.5", subjectId) ||
6548           GrouperClientUtils.equals("test.subject.6", subjectId));
6549 
6550       matcher = pattern.matcher(outputLines[3]);
6551 
6552       assertTrue(outputLines[3], matcher.matches());
6553 
6554       assertEquals(outputLines[3], "0", matcher.group(1));
6555       assertEquals(outputLines[3], "T", matcher.group(2));
6556       assertEquals(outputLines[3], "SUCCESS", matcher.group(3));
6557       assertEquals(outputLines[3], "aStem:aGroup", matcher.group(4));
6558       assertEquals(outputLines[3], "3", matcher.group(5));
6559       subjectId = matcher.group(6);
6560       assertTrue(outputLines[3], GrouperClientUtils.equals("test.subject.0", subjectId) ||
6561           GrouperClientUtils.equals("test.subject.1", subjectId) ||
6562           GrouperClientUtils.equals("test.subject.5", subjectId) ||
6563           GrouperClientUtils.equals("test.subject.6", subjectId));
6564 
6565       matcher = pattern.matcher(outputLines[4]);
6566 
6567       assertTrue(outputLines[4], matcher.matches());
6568 
6569       assertEquals(outputLines[4], "1", matcher.group(1));
6570       assertEquals(outputLines[4], "T", matcher.group(2));
6571       assertEquals(outputLines[4], "SUCCESS", matcher.group(3));
6572       assertEquals(outputLines[4], "aStem:aGroup2", matcher.group(4));
6573       assertEquals(outputLines[4], "0", matcher.group(5));
6574       subjectId = matcher.group(6);
6575       assertTrue(outputLines[4], GrouperClientUtils.equals("test.subject.2",
6576           subjectId)
6577           || GrouperClientUtils.equals("test.subject.3", subjectId));
6578 
6579       matcher = pattern.matcher(outputLines[5]);
6580 
6581       assertTrue(outputLines[5], matcher.matches());
6582 
6583       assertEquals(outputLines[5], "1", matcher.group(1));
6584       assertEquals(outputLines[5], "T", matcher.group(2));
6585       assertEquals(outputLines[5], "SUCCESS", matcher.group(3));
6586       assertEquals(outputLines[5], "aStem:aGroup2", matcher.group(4));
6587       assertEquals(outputLines[5], "1", matcher.group(5));
6588       subjectId = matcher.group(6);
6589       assertTrue(outputLines[5], GrouperClientUtils.equals("test.subject.2",
6590           subjectId)
6591           || GrouperClientUtils.equals("test.subject.3", subjectId));
6592 
6593 
6594       // ######################################################
6595       // Try a sourceId
6596 
6597       baos = new ByteArrayOutputStream();
6598       System.setOut(new PrintStream(baos));
6599 
6600       GrouperClient.main(GrouperClientUtils.splitTrim(
6601           "--operation=getMembersWs --groupNames=aStem:aGroup,aStem:aGroup2 --sourceIds=jdbc,g:gsa",
6602           " "));
6603 
6604       System.out.flush();
6605       output = new String(baos.toByteArray());
6606 
6607       System.setOut(systemOut);
6608 
6609       outputLines = GrouperClientUtils.splitTrim(output, "\n");
6610 
6611       assertEquals(4, GrouperUtil.length(outputLines));
6612 
6613       baos = new ByteArrayOutputStream();
6614       System.setOut(new PrintStream(baos));
6615 
6616       GrouperClient.main(GrouperClientUtils.splitTrim(
6617           "--operation=getMembersWs --groupNames=aStem:aGroup,aStem:aGroup2 --sourceIds=g:gsa",
6618           " "));
6619 
6620       System.out.flush();
6621       output = new String(baos.toByteArray());
6622 
6623       System.setOut(systemOut);
6624 
6625       outputLines = GrouperClientUtils.splitTrim(output, "\n");
6626 
6627       assertEquals(0, GrouperUtil.length(outputLines));
6628 
6629 
6630       // ######################################################
6631       // Try uuid
6632 
6633       baos = new ByteArrayOutputStream();
6634       System.setOut(new PrintStream(baos));
6635 
6636       Group aGroup = GroupFinder.findByName(grouperSession, "aStem:aGroup", true);
6637       Group aGroup2 = GroupFinder.findByName(grouperSession, "aStem:aGroup2", true);
6638 
6639       GrouperClient.main(GrouperClientUtils.splitTrim(
6640           "--operation=getMembersWs --groupUuids=" + aGroup.getUuid() + "," + aGroup2.getUuid(),
6641           " "));
6642 
6643       System.out.flush();
6644       output = new String(baos.toByteArray());
6645 
6646       System.setOut(systemOut);
6647 
6648       outputLines = GrouperClientUtils.splitTrim(output, "\n");
6649 
6650       assertEquals(4, GrouperUtil.length(outputLines));
6651 
6652 
6653       // ######################################################
6654       // Try id index
6655 
6656       baos = new ByteArrayOutputStream();
6657       System.setOut(new PrintStream(baos));
6658 
6659       GrouperClient.main(GrouperClientUtils.splitTrim(
6660           "--operation=getMembersWs --groupIdIndexes=" + aGroup.getIdIndex() + "," + aGroup2.getIdIndex(),
6661           " "));
6662 
6663       System.out.flush();
6664       output = new String(baos.toByteArray());
6665 
6666       System.setOut(systemOut);
6667 
6668       outputLines = GrouperClientUtils.splitTrim(output, "\n");
6669 
6670       assertEquals(4, GrouperUtil.length(outputLines));
6671 
6672 
6673       // ######################################################
6674       // Try a subject attribute name with custom template
6675 
6676       baos = new ByteArrayOutputStream();
6677       System.setOut(new PrintStream(baos));
6678 
6679       GrouperClient
6680           .main(GrouperClientUtils
6681               .splitTrim(
6682                   "--operation=getMembersWs --groupNames=aStem:aGroup,aStem:aGroup2 --subjectAttributeNames=a,name --outputTemplate=${wsSubject.getAttributeValue(1)}$newline$",
6683                   " "));
6684       System.out.flush();
6685       output = new String(baos.toByteArray());
6686 
6687       System.setOut(systemOut);
6688 
6689       outputLines = GrouperClientUtils.splitTrim(output, "\n");
6690 
6691       Arrays.sort(outputLines);
6692 
6693       assertEquals(outputLines[0], "my name is test.subject.0");
6694       assertEquals(outputLines[1], "my name is test.subject.1");
6695       assertEquals(outputLines[2], "my name is test.subject.2");
6696       assertEquals(outputLines[3], "my name is test.subject.3");
6697 
6698       // #######################################################
6699       // try member filter
6700 
6701       baos = new ByteArrayOutputStream();
6702       System.setOut(new PrintStream(baos));
6703 
6704       GrouperClient
6705           .main(GrouperClientUtils
6706               .splitTrim(
6707                   "--operation=getMembersWs --groupNames=aStem:aGroup,aStem:aGroup2 --memberFilter=Effective",
6708                   " "));
6709       System.out.flush();
6710       output = new String(baos.toByteArray());
6711 
6712       System.setOut(systemOut);
6713 
6714       assertTrue(GrouperClientWs.mostRecentRequest,
6715           GrouperClientWs.mostRecentRequest.contains("memberFilter"));
6716       assertTrue(GrouperClientWs.mostRecentRequest,
6717           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
6718       assertTrue(GrouperClientWs.mostRecentRequest,
6719           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
6720       assertTrue(GrouperClientWs.mostRecentRequest,
6721           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
6722       assertTrue(GrouperClientWs.mostRecentRequest,
6723           !GrouperClientWs.mostRecentRequest.contains("params"));
6724       assertTrue(GrouperClientWs.mostRecentRequest,
6725           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
6726       assertTrue(GrouperClientWs.mostRecentRequest,
6727           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
6728 
6729       // #######################################################
6730       // try member filter nonimmediate
6731 
6732       baos = new ByteArrayOutputStream();
6733       System.setOut(new PrintStream(baos));
6734 
6735       GrouperClient
6736           .main(GrouperClientUtils
6737               .splitTrim(
6738                   "--operation=getMembersWs --groupNames=aStem:aGroup,aStem:aGroup2 --memberFilter=NonImmediate",
6739                   " "));
6740       System.out.flush();
6741       output = new String(baos.toByteArray());
6742 
6743       System.setOut(systemOut);
6744 
6745       assertTrue(GrouperClientWs.mostRecentRequest,
6746           GrouperClientWs.mostRecentRequest.contains("memberFilter"));
6747       assertTrue(GrouperClientWs.mostRecentRequest,
6748           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
6749       assertTrue(GrouperClientWs.mostRecentRequest,
6750           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
6751       assertTrue(GrouperClientWs.mostRecentRequest,
6752           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
6753       assertTrue(GrouperClientWs.mostRecentRequest,
6754           !GrouperClientWs.mostRecentRequest.contains("params"));
6755       assertTrue(GrouperClientWs.mostRecentRequest,
6756           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
6757       assertTrue(GrouperClientWs.mostRecentRequest,
6758           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
6759 
6760       // #######################################################
6761       // try includeGroupDetail
6762 
6763       baos = new ByteArrayOutputStream();
6764       System.setOut(new PrintStream(baos));
6765 
6766       GrouperClient
6767           .main(GrouperClientUtils
6768               .splitTrim(
6769                   "--operation=getMembersWs --groupNames=aStem:aGroup,aStem:aGroup2 --includeGroupDetail=true",
6770                   " "));
6771       System.out.flush();
6772       output = new String(baos.toByteArray());
6773 
6774       System.setOut(systemOut);
6775 
6776       assertTrue(GrouperClientWs.mostRecentRequest,
6777           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
6778       assertTrue(GrouperClientWs.mostRecentRequest,
6779           GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
6780       assertTrue(GrouperClientWs.mostRecentRequest,
6781           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
6782       assertTrue(GrouperClientWs.mostRecentRequest,
6783           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
6784       assertTrue(GrouperClientWs.mostRecentRequest,
6785           !GrouperClientWs.mostRecentRequest.contains("params"));
6786       assertTrue(GrouperClientWs.mostRecentRequest,
6787           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
6788       assertTrue(GrouperClientWs.mostRecentRequest,
6789           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
6790 
6791       // #######################################################
6792       // try includeSubjectDetail
6793 
6794       baos = new ByteArrayOutputStream();
6795       System.setOut(new PrintStream(baos));
6796 
6797       GrouperClient
6798           .main(GrouperClientUtils
6799               .splitTrim(
6800                   "--operation=getMembersWs --groupNames=aStem:aGroup,aStem:aGroup2 --includeSubjectDetail=true",
6801                   " "));
6802       System.out.flush();
6803       output = new String(baos.toByteArray());
6804 
6805       System.setOut(systemOut);
6806 
6807       assertTrue(GrouperClientWs.mostRecentRequest,
6808           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
6809       assertTrue(GrouperClientWs.mostRecentRequest,
6810           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
6811       assertTrue(GrouperClientWs.mostRecentRequest,
6812           GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
6813       assertTrue(GrouperClientWs.mostRecentRequest,
6814           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
6815       assertTrue(GrouperClientWs.mostRecentRequest,
6816           !GrouperClientWs.mostRecentRequest.contains("params"));
6817       assertTrue(GrouperClientWs.mostRecentRequest,
6818           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
6819       assertTrue(GrouperClientWs.mostRecentRequest,
6820           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
6821 
6822       // #######################################################
6823       // try subjectAttributeNames
6824 
6825       baos = new ByteArrayOutputStream();
6826       System.setOut(new PrintStream(baos));
6827 
6828       GrouperClient
6829           .main(GrouperClientUtils
6830               .splitTrim(
6831                   "--operation=getMembersWs --groupNames=aStem:aGroup,aStem:aGroup2 --subjectAttributeNames=name",
6832                   " "));
6833       System.out.flush();
6834       output = new String(baos.toByteArray());
6835 
6836       System.setOut(systemOut);
6837 
6838       assertTrue(GrouperClientWs.mostRecentRequest,
6839           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
6840       assertTrue(GrouperClientWs.mostRecentRequest,
6841           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
6842       assertTrue(GrouperClientWs.mostRecentRequest,
6843           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
6844       assertTrue(GrouperClientWs.mostRecentRequest,
6845           GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
6846       assertTrue(GrouperClientWs.mostRecentRequest,
6847           !GrouperClientWs.mostRecentRequest.contains("params"));
6848       assertTrue(GrouperClientWs.mostRecentRequest,
6849           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
6850       assertTrue(GrouperClientWs.mostRecentRequest,
6851           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
6852 
6853       // #######################################################
6854       // try params
6855 
6856       baos = new ByteArrayOutputStream();
6857       System.setOut(new PrintStream(baos));
6858 
6859       GrouperClient
6860           .main(GrouperClientUtils
6861               .splitTrim(
6862                   "--operation=getMembersWs --groupNames=aStem:aGroup,aStem:aGroup2 --paramName0=someParam --paramValue0=someValue",
6863                   " "));
6864       System.out.flush();
6865       output = new String(baos.toByteArray());
6866 
6867       System.setOut(systemOut);
6868 
6869       assertTrue(GrouperClientWs.mostRecentRequest,
6870           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
6871       assertTrue(GrouperClientWs.mostRecentRequest,
6872           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
6873       assertTrue(GrouperClientWs.mostRecentRequest,
6874           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
6875       assertTrue(GrouperClientWs.mostRecentRequest,
6876           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
6877       assertTrue(GrouperClientWs.mostRecentRequest,
6878           GrouperClientWs.mostRecentRequest.contains("someParam")
6879               && GrouperClientWs.mostRecentRequest.toLowerCase().contains(
6880                   "params")
6881               && GrouperClientWs.mostRecentRequest.contains("someValue"));
6882       assertTrue(GrouperClientWs.mostRecentRequest,
6883           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
6884       assertTrue(GrouperClientWs.mostRecentRequest,
6885           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
6886 
6887       // #######################################################
6888       // try fieldName
6889 
6890       baos = new ByteArrayOutputStream();
6891       System.setOut(new PrintStream(baos));
6892 
6893       GrouperClient
6894           .main(GrouperClientUtils
6895               .splitTrim(
6896                   "--operation=getMembersWs --groupNames=aStem:aGroup,aStem:aGroup2 --fieldName=members",
6897                   " "));
6898       System.out.flush();
6899       output = new String(baos.toByteArray());
6900 
6901       System.setOut(systemOut);
6902 
6903       assertTrue(GrouperClientWs.mostRecentRequest,
6904           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
6905       assertTrue(GrouperClientWs.mostRecentRequest,
6906           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
6907       assertTrue(GrouperClientWs.mostRecentRequest,
6908           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
6909       assertTrue(GrouperClientWs.mostRecentRequest,
6910           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
6911       assertTrue(GrouperClientWs.mostRecentRequest,
6912           !GrouperClientWs.mostRecentRequest.contains("params"));
6913       assertTrue(GrouperClientWs.mostRecentRequest,
6914           GrouperClientWs.mostRecentRequest.contains("fieldName")
6915               && GrouperClientWs.mostRecentRequest.contains("members"));
6916       assertTrue(GrouperClientWs.mostRecentRequest,
6917           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
6918 
6919       // #######################################################
6920       // try actAsSubject
6921 
6922       baos = new ByteArrayOutputStream();
6923       System.setOut(new PrintStream(baos));
6924 
6925       GrouperClient
6926           .main(GrouperClientUtils
6927               .splitTrim(
6928                   "--operation=getMembersWs --groupNames=aStem:aGroup,aStem:aGroup2 --actAsSubjectId=GrouperSystem",
6929                   " "));
6930       System.out.flush();
6931       output = new String(baos.toByteArray());
6932 
6933       System.setOut(systemOut);
6934 
6935       assertTrue(GrouperClientWs.mostRecentRequest,
6936           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
6937       assertTrue(GrouperClientWs.mostRecentRequest,
6938           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
6939       assertTrue(GrouperClientWs.mostRecentRequest,
6940           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
6941       assertTrue(GrouperClientWs.mostRecentRequest,
6942           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
6943       assertTrue(GrouperClientWs.mostRecentRequest,
6944           !GrouperClientWs.mostRecentRequest.contains("params"));
6945       assertTrue(GrouperClientWs.mostRecentRequest,
6946           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
6947       assertTrue(GrouperClientWs.mostRecentRequest,
6948           GrouperClientWs.mostRecentRequest.contains("actAsSubject")
6949               && GrouperClientWs.mostRecentRequest.contains("GrouperSystem"));
6950 
6951       // #######################################################
6952       // try actAsSubject but with alias
6953 
6954       baos = new ByteArrayOutputStream();
6955       System.setOut(new PrintStream(baos));
6956 
6957       GrouperClient
6958           .main(GrouperClientUtils
6959               .splitTrim(
6960                   "--operation=getMembersWs --groupNames=aStem:aGroup,aStem:aGroup2 --actAsPennId=GrouperSystem",
6961                   " "));
6962       System.out.flush();
6963       output = new String(baos.toByteArray());
6964 
6965       System.setOut(systemOut);
6966 
6967       assertTrue(GrouperClientWs.mostRecentRequest,
6968           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
6969       assertTrue(GrouperClientWs.mostRecentRequest,
6970           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
6971       assertTrue(GrouperClientWs.mostRecentRequest,
6972           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
6973       assertTrue(GrouperClientWs.mostRecentRequest,
6974           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
6975       assertTrue(GrouperClientWs.mostRecentRequest,
6976           !GrouperClientWs.mostRecentRequest.contains("params"));
6977       assertTrue(GrouperClientWs.mostRecentRequest,
6978           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
6979       assertTrue(GrouperClientWs.mostRecentRequest,
6980           GrouperClientWs.mostRecentRequest.contains("actAsSubject")
6981               && GrouperClientWs.mostRecentRequest.contains("GrouperSystem"));
6982 
6983     } finally {
6984       System.setOut(systemOut);
6985     }
6986 
6987   }
6988 
6989   /**
6990    * @throws Exception
6991    */
6992   public void testGetGroups2() throws Exception {
6993 
6994     // make sure group exists
6995     @SuppressWarnings("unused")
6996     GrouperSession grouperSession = GrouperSession.startRootSession();
6997 
6998     Subject         subj  = SubjectTestHelper.SUBJ0;
6999     Subject         subj1  = SubjectTestHelper.SUBJ1;
7000     GrouperSession  s     = SessionHelper.getRootSession();
7001     Stem            root  = StemFinder.findRootStem(s);
7002     Stem            edu   = root.addChildStem("edu", "edu");
7003     Stem            eduSub   = edu.addChildStem("eduSub", "eduSub");
7004     Stem            edu2   = root.addChildStem("edu2", "edu2");
7005     Group           i2    = edu.addChildGroup("i2", "i2");
7006     Group           i2sub    = eduSub.addChildGroup("i2sub", "i2sub");
7007     Group           edu2i2sub    = edu2.addChildGroup("edu2i2sub", "edu2i2sub");
7008     Group           comp1    = edu.addChildGroup("comp1", "comp1");
7009     Group           compLeft    = edu.addChildGroup("compLeft", "compRight");
7010     Group           compRight    = edu.addChildGroup("compRight", "compRight");
7011 
7012     comp1.addCompositeMember(CompositeType.INTERSECTION, compLeft, compRight);
7013 
7014     compLeft.addMember(subj);
7015     compRight.addMember(subj);
7016 
7017     Group           uofc  = edu.addChildGroup("uofc", "uofc");
7018     GroupHelper.addMember(uofc, subj, "members");
7019     GroupHelper.addMember(i2, uofc.toSubject(), "members");
7020 
7021     i2sub.addMember(subj1);
7022     edu2i2sub.addMember(subj1);
7023 
7024     // give permissions
7025     String wsUserLabel = GrouperClientUtils.propertiesValue(
7026         "grouperClient.webService.user.label", true);
7027     String wsUserString = GrouperClientUtils.propertiesValue(
7028         "grouperClient.webService." + wsUserLabel, true);
7029     Subject wsUser = SubjectFinder.findByIdOrIdentifier(wsUserString, true);
7030 
7031     i2.grantPriv(wsUser, AccessPrivilege.READ, false);
7032     i2sub.grantPriv(wsUser, AccessPrivilege.READ, false);
7033     edu2i2sub.grantPriv(wsUser, AccessPrivilege.READ, false);
7034     comp1.grantPriv(wsUser, AccessPrivilege.READ, false);
7035     compLeft.grantPriv(wsUser, AccessPrivilege.READ, false);
7036     compRight.grantPriv(wsUser, AccessPrivilege.READ, false);
7037     uofc.grantPriv(wsUser, AccessPrivilege.READ, false);
7038 
7039 
7040     PrintStream systemOut = System.out;
7041 
7042     ByteArrayOutputStream baos = new ByteArrayOutputStream();
7043     System.setOut(new PrintStream(baos));
7044 
7045     //Set<Group> groups = member.getImmediateGroups();
7046     //assertEquals(3, groups.size());
7047     //assertTrue(groups.contains(compLeft));
7048     //assertTrue(groups.contains(compRight));
7049     //assertTrue(groups.contains(uofc));
7050 
7051     GrouperClient.main(GrouperClientUtils.splitTrim(
7052         "--operation=getGroupsWs --subjectIds=test.subject.0 --memberFilter=Immediate --sortString=name",
7053         " "));
7054     System.out.flush();
7055     String output = new String(baos.toByteArray());
7056 
7057     System.setOut(systemOut);
7058 
7059     System.out.println(output);
7060 
7061     String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
7062 
7063     assertEquals(3, outputLines.length);
7064 
7065     Pattern pattern = Pattern
7066         .compile("^SubjectIndex (\\d+): success: T: code: ([A-Z_]+): subject: (.*): groupIndex: (\\d+): (.*+)$");
7067     Matcher matcher = pattern.matcher(outputLines[0]);
7068 
7069     assertTrue(outputLines[0], matcher.matches());
7070 
7071     assertEquals("0", matcher.group(1));
7072     assertEquals("SUCCESS", matcher.group(2));
7073     assertEquals("test.subject.0", matcher.group(3));
7074     assertEquals("0", matcher.group(4));
7075     assertEquals(matcher.group(5), compLeft.getName(), matcher.group(5));
7076 
7077     matcher = pattern.matcher(outputLines[1]);
7078 
7079     assertTrue(outputLines[1], matcher.matches());
7080 
7081     assertEquals("0", matcher.group(1));
7082     assertEquals("SUCCESS", matcher.group(2));
7083     assertEquals("test.subject.0", matcher.group(3));
7084     assertEquals("1", matcher.group(4));
7085     assertEquals(matcher.group(5), compRight.getName(), matcher.group(5));
7086 
7087     matcher = pattern.matcher(outputLines[2]);
7088 
7089     assertTrue(outputLines[2], matcher.matches());
7090 
7091     assertEquals("0", matcher.group(1));
7092     assertEquals("SUCCESS", matcher.group(2));
7093     assertEquals("test.subject.0", matcher.group(3));
7094     assertEquals("2", matcher.group(4));
7095     assertEquals(matcher.group(5), uofc.getName(), matcher.group(5));
7096 
7097 
7098     // #####################################################
7099     //groups = member.getNonImmediateGroups();
7100     //assertEquals(2, groups.size());
7101     //assertTrue(groups.contains(comp1));
7102     //assertTrue(groups.contains(i2));
7103 
7104     baos = new ByteArrayOutputStream();
7105     System.setOut(new PrintStream(baos));
7106 
7107     // test a command line template
7108     GrouperClient
7109         .main(GrouperClientUtils
7110             .splitTrim(
7111                 "--operation=getGroupsWs --subjectIdentifiers=id.test.subject.0 --memberFilter=NonImmediate --sortString=name",
7112                 " "));
7113 
7114     System.out.flush();
7115 
7116     output = new String(baos.toByteArray());
7117 
7118     System.setOut(systemOut);
7119 
7120     System.out.println(output);
7121 
7122     outputLines = GrouperClientUtils.splitTrim(output, "\n");
7123 
7124     assertEquals(2, outputLines.length);
7125 
7126     pattern = Pattern
7127         .compile("^SubjectIndex (\\d+): success: T: code: ([A-Z_]+): subject: (.*): groupIndex: (\\d+): (.*+)$");
7128     matcher = pattern.matcher(outputLines[0]);
7129 
7130     assertTrue(outputLines[0], matcher.matches());
7131 
7132     assertEquals("0", matcher.group(1));
7133     assertEquals("SUCCESS", matcher.group(2));
7134     assertEquals("test.subject.0", matcher.group(3));
7135     assertEquals("0", matcher.group(4));
7136     assertEquals(matcher.group(5), comp1.getName(), matcher.group(5));
7137 
7138     matcher = pattern.matcher(outputLines[1]);
7139 
7140     assertTrue(outputLines[1], matcher.matches());
7141 
7142     assertEquals("0", matcher.group(1));
7143     assertEquals("SUCCESS", matcher.group(2));
7144     assertEquals("test.subject.0", matcher.group(3));
7145     assertEquals("1", matcher.group(4));
7146     assertEquals(matcher.group(5), i2.getName(), matcher.group(5));
7147 
7148     // #####################################################
7149     //groups = member1.getEffectiveGroups();
7150     //assertEquals(0, groups.size());
7151 
7152     baos = new ByteArrayOutputStream();
7153     System.setOut(new PrintStream(baos));
7154 
7155     // test a command line template
7156     GrouperClient
7157         .main(GrouperClientUtils
7158             .splitTrim(
7159                 "--operation=getGroupsWs --subjectIdentifiers=id.test.subject.1 --memberFilter=Effective",
7160                 " "));
7161 
7162     System.out.flush();
7163 
7164     output = new String(baos.toByteArray());
7165 
7166     System.setOut(systemOut);
7167 
7168     System.out.println(output);
7169 
7170     outputLines = GrouperClientUtils.splitTrim(output, "\n");
7171 
7172     assertEquals(0, GrouperClientUtils.length(outputLines));
7173 
7174     // #####################################################
7175     //groups = member1.getImmediateGroups(Group.getDefaultList(), "whatever", null, null, null, true);
7176     //assertEquals(0, groups.size());
7177 
7178     baos = new ByteArrayOutputStream();
7179     System.setOut(new PrintStream(baos));
7180 
7181     // test a command line template
7182     GrouperClient
7183         .main(GrouperClientUtils
7184             .splitTrim(
7185                 "--operation=getGroupsWs --subjectIdentifiers=id.test.subject.1 --memberFilter=Immediate --fieldName=members --enabled=T --scope=whatever",
7186                 " "));
7187 
7188     System.out.flush();
7189 
7190     output = new String(baos.toByteArray());
7191 
7192     System.setOut(systemOut);
7193 
7194     System.out.println(output);
7195 
7196     outputLines = GrouperClientUtils.splitTrim(output, "\n");
7197 
7198     assertEquals(0, GrouperClientUtils.length(outputLines));
7199 
7200     // #####################################################
7201     //groups = member1.getImmediateGroups(Group.getDefaultList(), "edu:eduSub", null, null, null, true);
7202     //assertEquals(1, groups.size());
7203     //assertEquals("edu:eduSub:i2sub", ((Group)GrouperUtil.get(groups, 0)).getName());
7204 
7205     baos = new ByteArrayOutputStream();
7206     System.setOut(new PrintStream(baos));
7207 
7208     // test a command line template
7209     GrouperClient
7210         .main(GrouperClientUtils
7211             .splitTrim(
7212                 "--operation=getGroupsWs --subjectIdentifiers=id.test.subject.1 --memberFilter=Immediate --scope=edu:eduSub",
7213                 " "));
7214 
7215     System.out.flush();
7216 
7217     output = new String(baos.toByteArray());
7218 
7219     System.setOut(systemOut);
7220 
7221     System.out.println(output);
7222 
7223     outputLines = GrouperClientUtils.splitTrim(output, "\n");
7224 
7225     assertEquals(1, outputLines.length);
7226 
7227     pattern = Pattern
7228         .compile("^SubjectIndex (\\d+): success: T: code: ([A-Z_]+): subject: (.*): groupIndex: (\\d+): (.*+)$");
7229     matcher = pattern.matcher(outputLines[0]);
7230 
7231     assertTrue(outputLines[0], matcher.matches());
7232 
7233     assertEquals("0", matcher.group(1));
7234     assertEquals("SUCCESS", matcher.group(2));
7235     assertEquals("test.subject.1", matcher.group(3));
7236     assertEquals("0", matcher.group(4));
7237     assertEquals(matcher.group(5), i2sub.getName(), matcher.group(5));
7238 
7239     // #####################################################
7240     //groups = member1.getImmediateGroups(Group.getDefaultList(), "edu2", null, null, null, true);
7241     //assertEquals(1, groups.size());
7242     //assertEquals("edu2:edu2i2sub", ((Group)GrouperUtil.get(groups, 0)).getName());
7243 
7244     baos = new ByteArrayOutputStream();
7245     System.setOut(new PrintStream(baos));
7246 
7247     // test a command line template
7248     GrouperClient
7249         .main(GrouperClientUtils
7250             .splitTrim(
7251                 "--operation=getGroupsWs --subjectIdentifiers=id.test.subject.1 --memberFilter=Immediate --scope=edu2",
7252                 " "));
7253 
7254     System.out.flush();
7255 
7256     output = new String(baos.toByteArray());
7257 
7258     System.setOut(systemOut);
7259 
7260     System.out.println(output);
7261 
7262     outputLines = GrouperClientUtils.splitTrim(output, "\n");
7263 
7264     assertEquals(1, outputLines.length);
7265 
7266     pattern = Pattern
7267         .compile("^SubjectIndex (\\d+): success: T: code: ([A-Z_]+): subject: (.*): groupIndex: (\\d+): (.*+)$");
7268     matcher = pattern.matcher(outputLines[0]);
7269 
7270     assertTrue(outputLines[0], matcher.matches());
7271 
7272     assertEquals("0", matcher.group(1));
7273     assertEquals("SUCCESS", matcher.group(2));
7274     assertEquals("test.subject.1", matcher.group(3));
7275     assertEquals("0", matcher.group(4));
7276     assertEquals(matcher.group(5), edu2i2sub.getName(), matcher.group(5));
7277 
7278     // #####################################################
7279     //groups = member1.getImmediateGroups(Group.getDefaultList(), "edu2", null, null, null, false);
7280     //assertEquals(0, groups.size());
7281 
7282     baos = new ByteArrayOutputStream();
7283     System.setOut(new PrintStream(baos));
7284 
7285     // test a command line template
7286     GrouperClient
7287         .main(GrouperClientUtils
7288             .splitTrim(
7289                 "--operation=getGroupsWs --subjectIdentifiers=id.test.subject.1 --memberFilter=Immediate --fieldName=members --enabled=F --scope=edu2",
7290                 " "));
7291 
7292     System.out.flush();
7293 
7294     output = new String(baos.toByteArray());
7295 
7296     System.setOut(systemOut);
7297 
7298     System.out.println(output);
7299 
7300     outputLines = GrouperClientUtils.splitTrim(output, "\n");
7301 
7302     assertEquals(0, GrouperClientUtils.length(outputLines));
7303 
7304 
7305     // #####################################################
7306     //try {
7307     //  groups = member1.getImmediateGroups(Group.getDefaultList(), null, edu, null, null, true);
7308     //  fail("Need stemScope");
7309     //} catch (Exception e) {
7310     //  //good
7311     //}
7312 
7313     baos = new ByteArrayOutputStream();
7314     System.setOut(new PrintStream(baos));
7315 
7316     // test a command line template
7317     try {
7318       GrouperClient
7319           .main(GrouperClientUtils
7320               .splitTrim(
7321                   "--operation=getGroupsWs --subjectIdentifiers=id.test.subject.1 --memberFilter=Immediate --stem=" + edu.getName(),
7322                   " "));
7323       fail("Need stemScope");
7324     } catch (Exception e) {
7325       //good
7326     } finally {
7327       System.out.flush();
7328 
7329       output = new String(baos.toByteArray());
7330 
7331       System.setOut(systemOut);
7332 
7333       System.out.println(output);
7334     }
7335 
7336     // #####################################################
7337     //groups = member1.getImmediateGroups(Group.getDefaultList(), null, edu, Scope.ONE, null, true);
7338     //assertEquals(0, groups.size());
7339 
7340     baos = new ByteArrayOutputStream();
7341     System.setOut(new PrintStream(baos));
7342 
7343     // test a command line template
7344     GrouperClient
7345         .main(GrouperClientUtils
7346             .splitTrim(
7347                 "--operation=getGroupsWs --subjectIdentifiers=id.test.subject.1 --memberFilter=Immediate --stemName=" + edu.getName() + " --stemScope=ONE_LEVEL",
7348                 " "));
7349 
7350     System.out.flush();
7351 
7352     output = new String(baos.toByteArray());
7353 
7354     System.setOut(systemOut);
7355 
7356     System.out.println(output);
7357 
7358     outputLines = GrouperClientUtils.splitTrim(output, "\n");
7359 
7360     assertEquals(0, GrouperClientUtils.length(outputLines));
7361 
7362     // #####################################################
7363     //groups = member1.getImmediateGroups(Group.getDefaultList(), null, edu2, Scope.ONE, null, true);
7364     //assertEquals(1, groups.size());
7365     //assertEquals("edu2:edu2i2sub", ((Group)GrouperUtil.get(groups, 0)).getName());
7366 
7367     baos = new ByteArrayOutputStream();
7368     System.setOut(new PrintStream(baos));
7369 
7370     // test a command line template
7371     GrouperClient
7372         .main(GrouperClientUtils
7373             .splitTrim(
7374                 "--operation=getGroupsWs --subjectIdentifiers=id.test.subject.1 --memberFilter=Immediate --stemName=" + edu2.getName() + " --stemScope=ONE_LEVEL",
7375                 " "));
7376 
7377     System.out.flush();
7378 
7379     output = new String(baos.toByteArray());
7380 
7381     System.setOut(systemOut);
7382 
7383     System.out.println(output);
7384 
7385     outputLines = GrouperClientUtils.splitTrim(output, "\n");
7386 
7387     assertEquals(1, outputLines.length);
7388 
7389     pattern = Pattern
7390         .compile("^SubjectIndex (\\d+): success: T: code: ([A-Z_]+): subject: (.*): groupIndex: (\\d+): (.*+)$");
7391     matcher = pattern.matcher(outputLines[0]);
7392 
7393     assertTrue(outputLines[0], matcher.matches());
7394 
7395     assertEquals("0", matcher.group(1));
7396     assertEquals("SUCCESS", matcher.group(2));
7397     assertEquals("test.subject.1", matcher.group(3));
7398     assertEquals("0", matcher.group(4));
7399     assertEquals(matcher.group(5), edu2i2sub.getName(), matcher.group(5));
7400 
7401     // #####################################################
7402     //groups = member1.getImmediateGroups(Group.getDefaultList(), null, edu, Scope.SUB, null, true);
7403     //assertEquals(1, groups.size());
7404     //assertEquals("edu:eduSub:i2sub", ((Group)GrouperUtil.get(groups, 0)).getName());
7405 
7406     baos = new ByteArrayOutputStream();
7407     System.setOut(new PrintStream(baos));
7408 
7409     // test a command line template
7410     GrouperClient
7411         .main(GrouperClientUtils
7412             .splitTrim(
7413                 "--operation=getGroupsWs --subjectIdentifiers=id.test.subject.1 --memberFilter=Immediate --stemName=" + edu.getName() + " --stemScope=ALL_IN_SUBTREE",
7414                 " "));
7415 
7416     System.out.flush();
7417 
7418     output = new String(baos.toByteArray());
7419 
7420     System.setOut(systemOut);
7421 
7422     System.out.println(output);
7423 
7424     outputLines = GrouperClientUtils.splitTrim(output, "\n");
7425 
7426     assertEquals(1, outputLines.length);
7427 
7428     pattern = Pattern
7429         .compile("^SubjectIndex (\\d+): success: T: code: ([A-Z_]+): subject: (.*): groupIndex: (\\d+): (.*+)$");
7430     matcher = pattern.matcher(outputLines[0]);
7431 
7432     assertTrue(outputLines[0], matcher.matches());
7433 
7434     assertEquals("0", matcher.group(1));
7435     assertEquals("SUCCESS", matcher.group(2));
7436     assertEquals("test.subject.1", matcher.group(3));
7437     assertEquals("0", matcher.group(4));
7438     assertEquals(matcher.group(5), i2sub.getName(), matcher.group(5));
7439 
7440     // #####################################################
7441     //groups = member1.getImmediateGroups(Group.getDefaultList(), null, edu2, Scope.SUB, null, true);
7442     //assertEquals(1, groups.size());
7443     //assertEquals("edu2:edu2i2sub", ((Group)GrouperUtil.get(groups, 0)).getName());
7444 
7445     baos = new ByteArrayOutputStream();
7446     System.setOut(new PrintStream(baos));
7447 
7448     // test a command line template
7449     GrouperClient
7450         .main(GrouperClientUtils
7451             .splitTrim(
7452                 "--operation=getGroupsWs --subjectIdentifiers=id.test.subject.1 --memberFilter=Immediate --stemName=" + edu2.getName() + " --stemScope=ALL_IN_SUBTREE",
7453                 " "));
7454 
7455     System.out.flush();
7456 
7457     output = new String(baos.toByteArray());
7458 
7459     System.setOut(systemOut);
7460 
7461     System.out.println(output);
7462 
7463     outputLines = GrouperClientUtils.splitTrim(output, "\n");
7464 
7465     assertEquals(1, outputLines.length);
7466 
7467     pattern = Pattern
7468         .compile("^SubjectIndex (\\d+): success: T: code: ([A-Z_]+): subject: (.*): groupIndex: (\\d+): (.*+)$");
7469     matcher = pattern.matcher(outputLines[0]);
7470 
7471     assertTrue(outputLines[0], matcher.matches());
7472 
7473     assertEquals("0", matcher.group(1));
7474     assertEquals("SUCCESS", matcher.group(2));
7475     assertEquals("test.subject.1", matcher.group(3));
7476     assertEquals("0", matcher.group(4));
7477     assertEquals(matcher.group(5), edu2i2sub.getName(), matcher.group(5));
7478 
7479     // #####################################################
7480     //QueryOptions queryOptions = new QueryOptions().paging(1, 1, true).sortAsc("name");
7481     //groups = member.getImmediateGroups(Group.getDefaultList(), null, null, null, queryOptions, true);
7482     //assertEquals(1, groups.size());
7483     //assertEquals("edu:compLeft", ((Group)GrouperUtil.get(groups, 0)).getName());
7484 
7485     baos = new ByteArrayOutputStream();
7486     System.setOut(new PrintStream(baos));
7487 
7488     // test a command line template
7489     GrouperClient
7490         .main(GrouperClientUtils
7491             .splitTrim(
7492                 "--operation=getGroupsWs --subjectIdentifiers=id.test.subject.0 --memberFilter=Immediate --pageSize=1 --pageNumber=1 --sortString=name",
7493                 " "));
7494 
7495     System.out.flush();
7496 
7497     output = new String(baos.toByteArray());
7498 
7499     System.setOut(systemOut);
7500 
7501     System.out.println(output);
7502 
7503     outputLines = GrouperClientUtils.splitTrim(output, "\n");
7504 
7505     assertEquals(1, outputLines.length);
7506 
7507     pattern = Pattern
7508         .compile("^SubjectIndex (\\d+): success: T: code: ([A-Z_]+): subject: (.*): groupIndex: (\\d+): (.*+)$");
7509     matcher = pattern.matcher(outputLines[0]);
7510 
7511     assertTrue(outputLines[0], matcher.matches());
7512 
7513     assertEquals("0", matcher.group(1));
7514     assertEquals("SUCCESS", matcher.group(2));
7515     assertEquals("test.subject.0", matcher.group(3));
7516     assertEquals("0", matcher.group(4));
7517     assertEquals(matcher.group(5), compLeft.getName(), matcher.group(5));
7518 
7519 
7520     // #####################################################
7521     //queryOptions = new QueryOptions().paging(1, 1, true).sortAsc("non existent column");
7522     //try {
7523     //  groups = member.getImmediateGroups(Group.getDefaultList(), null, null, null, queryOptions, true);
7524     //  fail("Column doesnt exist");
7525     //} catch (Exception e) {
7526     //  //good
7527     //}
7528 
7529     baos = new ByteArrayOutputStream();
7530     System.setOut(new PrintStream(baos));
7531 
7532     try {
7533       // test a command line template
7534       GrouperClient
7535           .main(GrouperClientUtils
7536               .splitTrim(
7537                   "--operation=getGroupsWs --subjectIdentifiers=id.test.subject.0 --memberFilter=Immediate --pageSize=1 --pageNumber=1 --sortString=doesntExist",
7538                   " "));
7539       fail("Column doesnt exist");
7540     } catch (Exception e) {
7541       //good
7542     } finally {
7543       System.out.flush();
7544 
7545       output = new String(baos.toByteArray());
7546 
7547       System.setOut(systemOut);
7548 
7549       System.out.println(output);
7550     }
7551 
7552   }
7553 
7554   /**
7555    *
7556    * @throws Exception
7557    */
7558   public void testGetMembershipsForService() throws Exception {
7559 
7560     GrouperSession grouperSession = GrouperSession.startRootSession();
7561 
7562     AttributeDefName jiraService = null;
7563     AttributeDefName confluenceService = null;
7564     AttributeDefName directoryService = null;
7565 
7566     //create three services, one directly in, one hierarchical, one the user is not in
7567     AttributeDef jiraServiceDef = new AttributeDefSave(grouperSession)
7568       .assignCreateParentStemsIfNotExist(true).assignAttributeDefType(AttributeDefType.service)
7569       .assignName("apps:jira:jiraServiceDefinition").assignToStem(true).save();
7570 
7571     jiraService = new AttributeDefNameSave(grouperSession, jiraServiceDef)
7572       .assignCreateParentStemsIfNotExist(true)
7573       .assignName("apps:jira:jiraService").assignDisplayExtension("Central IT production Jira issue tracker").save();
7574 
7575     //jira group
7576     Group jiraGroup = new GroupSave(grouperSession)
7577       .assignName("apps:jira:groups:admins").assignCreateParentStemsIfNotExist(true).save();
7578 
7579     jiraGroup.revokePriv(SubjectFinder.findAllSubject(), AccessPrivilege.READ, false);
7580     jiraGroup.revokePriv(grouperSession.getSubject(), AccessPrivilege.ADMIN, false);
7581     jiraGroup.grantPriv(SubjectTestHelper.SUBJ5, AccessPrivilege.READ, false);
7582     jiraGroup.grantPriv(SubjectTestHelper.SUBJ6, AccessPrivilege.ADMIN, false);
7583 
7584     jiraGroup.addMember(SubjectTestHelper.SUBJ0);
7585     jiraGroup.addMember(SubjectTestHelper.SUBJ1);
7586 
7587     //the jira group has the jira service tag
7588     Stem jiraStem = StemFinder.findByUuid(grouperSession, jiraGroup.getStemId(), true);
7589     jiraStem.getAttributeDelegate().assignAttribute(jiraService);
7590 
7591     AttributeDef confluenceServiceDef = new AttributeDefSave(grouperSession)
7592       .assignCreateParentStemsIfNotExist(true).assignAttributeDefType(AttributeDefType.service)
7593       .assignName("apps:confluence:confluenceServiceDefinition").assignToStem(true).save();
7594 
7595     confluenceService = new AttributeDefNameSave(grouperSession, confluenceServiceDef)
7596       .assignCreateParentStemsIfNotExist(true)
7597       .assignName("apps:confluence:confluenceService").assignDisplayExtension("Central IT production Confluence wiki").save();
7598 
7599     Group confluenceGroup = new GroupSave(grouperSession)
7600       .assignName("apps:confluence:editors").assignCreateParentStemsIfNotExist(true).save();
7601 
7602     confluenceGroup.revokePriv(SubjectFinder.findAllSubject(), AccessPrivilege.READ);
7603     confluenceGroup.revokePriv(grouperSession.getSubject(), AccessPrivilege.ADMIN);
7604     confluenceGroup.grantPriv(SubjectTestHelper.SUBJ6, AccessPrivilege.READ);
7605     confluenceGroup.grantPriv(SubjectTestHelper.SUBJ7, AccessPrivilege.ADMIN);
7606     confluenceGroup.grantPriv(SubjectTestHelper.SUBJ8, AccessPrivilege.UPDATE);
7607 
7608     confluenceGroup.addMember(SubjectTestHelper.SUBJ1);
7609     confluenceGroup.addMember(SubjectTestHelper.SUBJ2);
7610 
7611     //the confluence folder has the confluence service tag
7612     Stem confluenceFolder = StemFinder.findByName(grouperSession, "apps:confluence", true);
7613     confluenceFolder.getAttributeDelegate().assignAttribute(confluenceService);
7614 
7615     AttributeDef directoryServiceDef = new AttributeDefSave(grouperSession)
7616       .assignCreateParentStemsIfNotExist(true).assignAttributeDefType(AttributeDefType.service)
7617       .assignName("apps:directory:directoryServiceDefinition").assignToStem(true).save();
7618 
7619     directoryService = new AttributeDefNameSave(grouperSession, directoryServiceDef)
7620       .assignCreateParentStemsIfNotExist(true)
7621       .assignName("apps:directory:directoryService").assignDisplayExtension("MySchool directory").save();
7622 
7623     Group directoryGroup = new GroupSave(grouperSession)
7624       .assignName("apps:directory:users").assignCreateParentStemsIfNotExist(true).save();
7625 
7626     directoryGroup.revokePriv(SubjectFinder.findAllSubject(), AccessPrivilege.READ);
7627     directoryGroup.grantPriv(SubjectTestHelper.SUBJ7, AccessPrivilege.READ);
7628     directoryGroup.grantPriv(SubjectTestHelper.SUBJ8, AccessPrivilege.READ);
7629     directoryGroup.addMember(SubjectTestHelper.SUBJ2);
7630     directoryGroup.addMember(SubjectTestHelper.SUBJ3);
7631 
7632     //the confluence folder has the confluence service tag
7633     Stem directoryFolder = StemFinder.findByName(grouperSession, "apps:directory", true);
7634     directoryFolder.getAttributeDelegate().assignAttribute(directoryService);
7635 
7636     PrintStream systemOut = System.out;
7637 
7638     ByteArrayOutputStream baos = new ByteArrayOutputStream();
7639     System.setOut(new PrintStream(baos));
7640 
7641     try {
7642 
7643       // ##################### subject 0 and 1 are in the jira service...
7644 
7645       GrouperClient.main(GrouperClientUtils.splitTrim(
7646           "--operation=getMembershipsWs --serviceId=" + jiraService.getId() + " --serviceRole=user",
7647           " "));
7648       System.out.flush();
7649       String output = new String(baos.toByteArray());
7650 
7651       System.setOut(systemOut);
7652 
7653       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
7654 
7655       assertEquals(2, GrouperUtil.length(outputLines));
7656 
7657       // match: Index: 0: group: aStem:aGroup, subject: GrouperSystem, list: members, type: immediate, enabled: T
7658       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
7659       Pattern pattern = Pattern
7660           .compile("^Index: (\\d+)\\: group\\: (.+), subject\\: (.+), list: (.+), type\\: (.+), enabled\\: (T|F)$");
7661       String outputLine = outputLines[0];
7662 
7663       Matcher matcher = pattern.matcher(outputLines[0]);
7664 
7665       assertTrue(outputLine, matcher.matches());
7666       assertEquals(outputLine, "0", matcher.group(1));
7667       assertEquals(outputLine, "apps:jira:groups:admins", matcher.group(2));
7668       assertEquals(outputLine, "test.subject.0", matcher.group(3));
7669       assertEquals(outputLine, "members", matcher.group(4));
7670       assertEquals(outputLine, "immediate", matcher.group(5));
7671       assertEquals(outputLine, "T", matcher.group(6));
7672 
7673       outputLine = outputLines[1];
7674 
7675       matcher = pattern.matcher(outputLine);
7676 
7677       assertTrue(outputLine, matcher.matches());
7678 
7679       assertEquals(outputLine, "1", matcher.group(1));
7680       assertEquals(outputLine, "apps:jira:groups:admins", matcher.group(2));
7681       assertEquals(outputLine, "test.subject.1", matcher.group(3));
7682       assertEquals(outputLine, "members", matcher.group(4));
7683       assertEquals(outputLine, "immediate", matcher.group(5));
7684       assertEquals(outputLine, "T", matcher.group(6));
7685 
7686       assertTrue(GrouperClientWs.mostRecentRequest,
7687           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
7688       assertTrue(GrouperClientWs.mostRecentRequest,
7689           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
7690       assertTrue(GrouperClientWs.mostRecentRequest,
7691           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
7692       assertTrue(GrouperClientWs.mostRecentRequest,
7693           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
7694       assertTrue(GrouperClientWs.mostRecentRequest,
7695           !GrouperClientWs.mostRecentRequest.contains("params"));
7696       assertTrue(GrouperClientWs.mostRecentRequest,
7697           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
7698       assertTrue(GrouperClientWs.mostRecentRequest,
7699           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
7700       assertTrue(GrouperClientWs.mostRecentRequest,
7701           GrouperClientWs.mostRecentRequest.contains("serviceRole"));
7702       assertTrue(GrouperClientWs.mostRecentRequest,
7703           GrouperClientWs.mostRecentRequest.contains("<serviceLookup><uuid>"));
7704       assertTrue(GrouperClientWs.mostRecentRequest,
7705           !GrouperClientWs.mostRecentRequest.contains("<serviceLookup><name>"));
7706 
7707       // ##################### subject 7 and 8 is admin of the confluence service...
7708 
7709       baos = new ByteArrayOutputStream();
7710       System.setOut(new PrintStream(baos));
7711 
7712       GrouperClient.main(GrouperClientUtils.splitTrim(
7713           "--operation=getMembershipsWs --serviceName=" + confluenceService.getName() + " --serviceRole=admin",
7714           " "));
7715       System.out.flush();
7716       output = new String(baos.toByteArray());
7717 
7718       System.setOut(systemOut);
7719 
7720       outputLines = GrouperClientUtils.splitTrim(output, "\n");
7721 
7722       assertEquals(2, GrouperUtil.length(outputLines));
7723 
7724       // match: Index: 0: group: aStem:aGroup, subject: GrouperSystem, list: members, type: immediate, enabled: T
7725       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
7726       pattern = Pattern
7727           .compile("^Index: (\\d+)\\: group\\: (.+), subject\\: (.+), list: (.+), type\\: (.+), enabled\\: (T|F)$");
7728       outputLine = outputLines[0];
7729 
7730       matcher = pattern.matcher(outputLines[0]);
7731 
7732       assertTrue(outputLine, matcher.matches());
7733       assertEquals(outputLine, "0", matcher.group(1));
7734       assertEquals(outputLine, "apps:confluence:editors", matcher.group(2));
7735       assertEquals(outputLine, "test.subject.7", matcher.group(3));
7736       assertEquals(outputLine, "admins", matcher.group(4));
7737       assertEquals(outputLine, "immediate", matcher.group(5));
7738       assertEquals(outputLine, "T", matcher.group(6));
7739 
7740       matcher = pattern.matcher(outputLines[1]);
7741 
7742       assertTrue(outputLine, matcher.matches());
7743       assertEquals(outputLine, "1", matcher.group(1));
7744       assertEquals(outputLine, "apps:confluence:editors", matcher.group(2));
7745       assertEquals(outputLine, "test.subject.8", matcher.group(3));
7746       assertEquals(outputLine, "updaters", matcher.group(4));
7747       assertEquals(outputLine, "immediate", matcher.group(5));
7748       assertEquals(outputLine, "T", matcher.group(6));
7749 
7750 
7751       assertTrue(GrouperClientWs.mostRecentRequest,
7752           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
7753       assertTrue(GrouperClientWs.mostRecentRequest,
7754           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
7755       assertTrue(GrouperClientWs.mostRecentRequest,
7756           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
7757       assertTrue(GrouperClientWs.mostRecentRequest,
7758           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
7759       assertTrue(GrouperClientWs.mostRecentRequest,
7760           !GrouperClientWs.mostRecentRequest.contains("params"));
7761       assertTrue(GrouperClientWs.mostRecentRequest,
7762           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
7763       assertTrue(GrouperClientWs.mostRecentRequest,
7764           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
7765       assertTrue(GrouperClientWs.mostRecentRequest,
7766           GrouperClientWs.mostRecentRequest.contains("serviceRole"));
7767       assertTrue(GrouperClientWs.mostRecentRequest,
7768           GrouperClientWs.mostRecentRequest.contains("<serviceLookup><name>"));
7769       assertTrue(GrouperClientWs.mostRecentRequest,
7770           !GrouperClientWs.mostRecentRequest.contains("<serviceLookup><uuid>"));
7771 
7772     } finally {
7773       System.setOut(systemOut);
7774     }
7775 
7776   }
7777 
7778   /**
7779    * @throws Exception
7780    */
7781   public void testGetMemberships() throws Exception {
7782 
7783     // make sure group exists
7784     GrouperSession grouperSession = GrouperSession.startRootSession();
7785     Group group = Group.saveGroup(grouperSession, "aStem:aGroup", null,
7786         "aStem:aGroup", "aGroup", null, null, true);
7787     Group group2 = Group.saveGroup(grouperSession, "aStem:aGroup2", null,
7788         "aStem:aGroup2", "aGroup2", null, null, true);
7789 
7790     Stem stem = new StemSave(grouperSession).assignName("aStem1").assignCreateParentStemsIfNotExist(true).save();
7791     Stem stem2 = new StemSave(grouperSession).assignName("aStem2").assignCreateParentStemsIfNotExist(true).save();
7792 
7793     AttributeDef attributeDef = new AttributeDefSave(grouperSession).assignName("aStem1:attributeDef1").assignCreateParentStemsIfNotExist(true).save();
7794     AttributeDef attributeDef2 = new AttributeDefSave(grouperSession).assignName("aStem2:attributeDef2").assignCreateParentStemsIfNotExist(true).save();
7795 
7796     // give permissions
7797     String wsUserLabel = GrouperClientUtils.propertiesValue(
7798         "grouperClient.webService.user.label", true);
7799     String wsUserString = GrouperClientUtils.propertiesValue(
7800         "grouperClient.webService." + wsUserLabel, true);
7801     Subject wsUser = SubjectFinder.findByIdOrIdentifier(wsUserString, true);
7802 
7803     group.grantPriv(wsUser, AccessPrivilege.ADMIN, false);
7804     group2.grantPriv(wsUser, AccessPrivilege.ADMIN, false);
7805     stem.grantPriv(wsUser, NamingPrivilege.STEM, false);
7806     stem2.grantPriv(wsUser, NamingPrivilege.STEM, false);
7807     attributeDef.getPrivilegeDelegate().grantPriv(wsUser, AttributeDefPrivilege.ATTR_ADMIN, false);
7808     attributeDef2.getPrivilegeDelegate().grantPriv(wsUser, AttributeDefPrivilege.ATTR_ADMIN, false);
7809 
7810     // add some subjects
7811     group.addMember(SubjectTestHelper.SUBJ0, false);
7812     group.addMember(SubjectTestHelper.SUBJ1, false);
7813     group2.addMember(SubjectTestHelper.SUBJ2, false);
7814     group2.addMember(SubjectTestHelper.SUBJ3, false);
7815 
7816     group.grantPriv(SubjectTestHelper.SUBJ7, AccessPrivilege.UPDATE, false);
7817     group.grantPriv(SubjectTestHelper.SUBJ8, AccessPrivilege.ADMIN, false);
7818     group2.grantPriv(SubjectTestHelper.SUBJ7, AccessPrivilege.UPDATE, false);
7819     group2.grantPriv(SubjectTestHelper.SUBJ8, AccessPrivilege.ADMIN, false);
7820 
7821     stem.grantPriv(SubjectTestHelper.SUBJ7, NamingPrivilege.CREATE, false);
7822     stem.grantPriv(SubjectTestHelper.SUBJ8, NamingPrivilege.STEM, false);
7823     stem2.grantPriv(SubjectTestHelper.SUBJ7, NamingPrivilege.CREATE, false);
7824     stem2.grantPriv(SubjectTestHelper.SUBJ8, NamingPrivilege.STEM, false);
7825 
7826     attributeDef.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ7, AttributeDefPrivilege.ATTR_READ, false);
7827     attributeDef.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ8, AttributeDefPrivilege.ATTR_UPDATE, false);
7828     attributeDef2.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ7, AttributeDefPrivilege.ATTR_READ, false);
7829     attributeDef2.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ8, AttributeDefPrivilege.ATTR_UPDATE, false);
7830 
7831     GrouperSession.stopQuietly(grouperSession);
7832     grouperSession = GrouperSession.start(wsUser);
7833 
7834     Set<Object[]> results = new MembershipFinder().addSubject(SubjectTestHelper.SUBJ7)
7835         .addSubject(SubjectTestHelper.SUBJ8).assignFieldType(FieldType.ACCESS).findMembershipsMembers();
7836 
7837     assertEquals(GrouperUtil.toStringForLog(results), 4, GrouperUtil.length(results));
7838 
7839     GrouperSession.stopQuietly(grouperSession);
7840     grouperSession = GrouperSession.startRootSession();
7841 
7842 
7843     PrintStream systemOut = System.out;
7844 
7845     ByteArrayOutputStream baos = new ByteArrayOutputStream();
7846     System.setOut(new PrintStream(baos));
7847 
7848     try {
7849 
7850       GrouperClient.main(GrouperClientUtils.splitTrim(
7851           "--operation=getMembershipsWs --groupNames=aStem:aGroup,aStem:aGroup2",
7852           " "));
7853       System.out.flush();
7854       String output = new String(baos.toByteArray());
7855 
7856       System.setOut(systemOut);
7857 
7858       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
7859 
7860       // OLD match: Index: 0: type: group, ownerName: aStem:aGroup, subject: GrouperSystem, list: members, type: immediate, enabled: T
7861       // NEW match: Index: 0: group: aStem:aGroup, subject: test.subject.0, list: members, type: immediate, enabled: T
7862       // match: ^Index: (\d+)\: type: group, ownerName\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
7863       Pattern pattern = Pattern
7864           .compile("^Index: (\\d+)\\: group\\: (.+), subject\\: (.+), list: (.+), type\\: (.+), enabled\\: (T|F)$");
7865       String outputLine = outputLines[0];
7866 
7867       Matcher matcher = pattern.matcher(outputLines[0]);
7868 
7869       assertTrue(outputLine, matcher.matches());
7870       assertEquals(outputLine, "0", matcher.group(1));
7871       assertEquals(outputLine, "aStem:aGroup", matcher.group(2));
7872       assertEquals(outputLine, "test.subject.0", matcher.group(3));
7873       assertEquals(outputLine, "members", matcher.group(4));
7874       assertEquals(outputLine, "immediate", matcher.group(5));
7875       assertEquals(outputLine, "T", matcher.group(6));
7876 
7877       outputLine = outputLines[1];
7878 
7879       matcher = pattern.matcher(outputLine);
7880 
7881       assertTrue(outputLine, matcher.matches());
7882 
7883       assertEquals(outputLine, "1", matcher.group(1));
7884       assertEquals(outputLine, "aStem:aGroup", matcher.group(2));
7885       assertEquals(outputLine, "test.subject.1", matcher.group(3));
7886       assertEquals(outputLine, "members", matcher.group(4));
7887       assertEquals(outputLine, "immediate", matcher.group(5));
7888       assertEquals(outputLine, "T", matcher.group(6));
7889 
7890       outputLine = outputLines[2];
7891 
7892       matcher = pattern.matcher(outputLine);
7893 
7894       assertTrue(outputLine, matcher.matches());
7895 
7896       assertEquals(outputLine, "2", matcher.group(1));
7897       assertEquals(outputLine, "aStem:aGroup2", matcher.group(2));
7898       assertEquals(outputLine, "test.subject.2", matcher.group(3));
7899       assertEquals(outputLine, "members", matcher.group(4));
7900       assertEquals(outputLine, "immediate", matcher.group(5));
7901       assertEquals(outputLine, "T", matcher.group(6));
7902 
7903       outputLine = outputLines[3];
7904 
7905       matcher = pattern.matcher(outputLine);
7906 
7907       assertTrue(outputLine, matcher.matches());
7908 
7909       assertEquals(outputLine, "3", matcher.group(1));
7910       assertEquals(outputLine, "aStem:aGroup2", matcher.group(2));
7911       assertEquals(outputLine, "test.subject.3", matcher.group(3));
7912       assertEquals(outputLine, "members", matcher.group(4));
7913       assertEquals(outputLine, "immediate", matcher.group(5));
7914       assertEquals(outputLine, "T", matcher.group(6));
7915 
7916       assertTrue(GrouperClientWs.mostRecentRequest,
7917           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
7918       assertTrue(GrouperClientWs.mostRecentRequest,
7919           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
7920       assertTrue(GrouperClientWs.mostRecentRequest,
7921           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
7922       assertTrue(GrouperClientWs.mostRecentRequest,
7923           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
7924       assertTrue(GrouperClientWs.mostRecentRequest,
7925           !GrouperClientWs.mostRecentRequest.contains("params"));
7926       assertTrue(GrouperClientWs.mostRecentRequest,
7927           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
7928       assertTrue(GrouperClientWs.mostRecentRequest,
7929           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
7930       assertTrue(GrouperClientWs.mostRecentRequest,
7931           !GrouperClientWs.mostRecentRequest.contains("serviceRole"));
7932       assertTrue(GrouperClientWs.mostRecentRequest,
7933           !GrouperClientWs.mostRecentRequest.contains("<serviceLookup><uuid>"));
7934 
7935       // ######################################################
7936       // Try a sourceId
7937 
7938       baos = new ByteArrayOutputStream();
7939       System.setOut(new PrintStream(baos));
7940 
7941       GrouperClient.main(GrouperClientUtils.splitTrim(
7942           "--operation=getMembershipsWs --groupNames=aStem:aGroup,aStem:aGroup2 --sourceIds=jdbc,g:gsa",
7943           " "));
7944 
7945       System.out.flush();
7946       output = new String(baos.toByteArray());
7947 
7948       System.setOut(systemOut);
7949 
7950       outputLines = GrouperClientUtils.splitTrim(output, "\n");
7951 
7952       assertEquals(4, GrouperUtil.length(outputLines));
7953 
7954       //##########################################################
7955       //Try a source id with no results
7956 
7957       baos = new ByteArrayOutputStream();
7958       System.setOut(new PrintStream(baos));
7959 
7960       GrouperClient.main(GrouperClientUtils.splitTrim(
7961           "--operation=getMembershipsWs --groupNames=aStem:aGroup,aStem:aGroup2 --sourceIds=g:gsa",
7962           " "));
7963 
7964       System.out.flush();
7965       output = new String(baos.toByteArray());
7966 
7967       System.setOut(systemOut);
7968 
7969       outputLines = GrouperClientUtils.splitTrim(output, "\n");
7970 
7971       assertEquals(0, GrouperUtil.length(outputLines));
7972 
7973 
7974       // ######################################################
7975       // Try uuid
7976 
7977       baos = new ByteArrayOutputStream();
7978       System.setOut(new PrintStream(baos));
7979 
7980       Group aGroup = GroupFinder.findByName(grouperSession, "aStem:aGroup", true);
7981       Group aGroup2 = GroupFinder.findByName(grouperSession, "aStem:aGroup2", true);
7982 
7983       GrouperClient.main(GrouperClientUtils.splitTrim(
7984           "--operation=getMembershipsWs --groupUuids=" + aGroup.getUuid() + "," + aGroup2.getUuid(),
7985           " "));
7986 
7987       System.out.flush();
7988       output = new String(baos.toByteArray());
7989 
7990       System.setOut(systemOut);
7991 
7992       outputLines = GrouperClientUtils.splitTrim(output, "\n");
7993 
7994       assertEquals(4, GrouperUtil.length(outputLines));
7995 
7996       // ######################################################
7997       // Try id index
7998 
7999       baos = new ByteArrayOutputStream();
8000       System.setOut(new PrintStream(baos));
8001 
8002       aGroup = GroupFinder.findByName(grouperSession, "aStem:aGroup", true);
8003       aGroup2 = GroupFinder.findByName(grouperSession, "aStem:aGroup2", true);
8004       Stem aStem = StemFinder.findByName(grouperSession, "aStem", true);
8005 
8006       GrouperClient.main(GrouperClientUtils.splitTrim(
8007           "--operation=getMembershipsWs --groupIdIndexes=" + aGroup.getIdIndex() + "," + aGroup2.getIdIndex(),
8008           " "));
8009 
8010       System.out.flush();
8011       output = new String(baos.toByteArray());
8012 
8013       System.setOut(systemOut);
8014 
8015       outputLines = GrouperClientUtils.splitTrim(output, "\n");
8016 
8017       assertEquals(4, GrouperUtil.length(outputLines));
8018 
8019 
8020       // ######################################################
8021       // Try a subject attribute name with custom template
8022 
8023       baos = new ByteArrayOutputStream();
8024       System.setOut(new PrintStream(baos));
8025 
8026       GrouperClient
8027           .main(GrouperClientUtils
8028               .splitTrim(
8029                   "--operation=getMembershipsWs --groupNames=aStem:aGroup,aStem:aGroup2 --subjectAttributeNames=a,name --outputTemplate=${wsSubject.getAttributeValue(1)}$newline$",
8030                   " "));
8031       System.out.flush();
8032       output = new String(baos.toByteArray());
8033 
8034       System.setOut(systemOut);
8035 
8036       outputLines = GrouperClientUtils.splitTrim(output, "\n");
8037 
8038       Arrays.sort(outputLines);
8039 
8040       assertEquals(outputLines[0], "my name is test.subject.0");
8041       assertEquals(outputLines[1], "my name is test.subject.1");
8042       assertEquals(outputLines[2], "my name is test.subject.2");
8043       assertEquals(outputLines[3], "my name is test.subject.3");
8044 
8045       // #######################################################
8046       // try member filter
8047 
8048       baos = new ByteArrayOutputStream();
8049       System.setOut(new PrintStream(baos));
8050 
8051       GrouperClient
8052           .main(GrouperClientUtils
8053               .splitTrim(
8054                   "--operation=getMembershipsWs --groupNames=aStem:aGroup,aStem:aGroup2 --memberFilter=Effective",
8055                   " "));
8056       System.out.flush();
8057       output = new String(baos.toByteArray());
8058 
8059       System.setOut(systemOut);
8060 
8061       outputLines = GrouperClientUtils.splitTrim(output, "\n");
8062 
8063       assertEquals(0, GrouperUtil.length(outputLines));
8064 
8065       assertTrue(GrouperClientWs.mostRecentRequest,
8066           GrouperClientWs.mostRecentRequest.contains("memberFilter"));
8067       assertTrue(GrouperClientWs.mostRecentRequest,
8068           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
8069       assertTrue(GrouperClientWs.mostRecentRequest,
8070           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
8071       assertTrue(GrouperClientWs.mostRecentRequest,
8072           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
8073       assertTrue(GrouperClientWs.mostRecentRequest,
8074           !GrouperClientWs.mostRecentRequest.contains("params"));
8075       assertTrue(GrouperClientWs.mostRecentRequest,
8076           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
8077       assertTrue(GrouperClientWs.mostRecentRequest,
8078           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
8079 
8080       // #######################################################
8081       // try member filter nonimmediate
8082 
8083       baos = new ByteArrayOutputStream();
8084       System.setOut(new PrintStream(baos));
8085 
8086       GrouperClient
8087           .main(GrouperClientUtils
8088               .splitTrim(
8089                   "--operation=getMembershipsWs --groupNames=aStem:aGroup,aStem:aGroup2 --memberFilter=NonImmediate",
8090                   " "));
8091       System.out.flush();
8092       output = new String(baos.toByteArray());
8093 
8094       System.setOut(systemOut);
8095 
8096       outputLines = GrouperClientUtils.splitTrim(output, "\n");
8097 
8098       assertEquals(0, GrouperUtil.length(outputLines));
8099 
8100       assertTrue(GrouperClientWs.mostRecentRequest,
8101           GrouperClientWs.mostRecentRequest.contains("memberFilter"));
8102       assertTrue(GrouperClientWs.mostRecentRequest,
8103           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
8104       assertTrue(GrouperClientWs.mostRecentRequest,
8105           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
8106       assertTrue(GrouperClientWs.mostRecentRequest,
8107           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
8108       assertTrue(GrouperClientWs.mostRecentRequest,
8109           !GrouperClientWs.mostRecentRequest.contains("params"));
8110       assertTrue(GrouperClientWs.mostRecentRequest,
8111           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
8112       assertTrue(GrouperClientWs.mostRecentRequest,
8113           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
8114 
8115       // #######################################################
8116       // try includeGroupDetail
8117 
8118       baos = new ByteArrayOutputStream();
8119       System.setOut(new PrintStream(baos));
8120 
8121       GrouperClient
8122           .main(GrouperClientUtils
8123               .splitTrim(
8124                   "--operation=getMembershipsWs --groupNames=aStem:aGroup,aStem:aGroup2 --includeGroupDetail=true",
8125                   " "));
8126       System.out.flush();
8127       output = new String(baos.toByteArray());
8128 
8129       System.setOut(systemOut);
8130 
8131       outputLines = GrouperClientUtils.splitTrim(output, "\n");
8132 
8133       assertEquals(4, GrouperUtil.length(outputLines));
8134 
8135       assertTrue(GrouperClientWs.mostRecentRequest,
8136           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
8137       assertTrue(GrouperClientWs.mostRecentRequest,
8138           GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
8139       assertTrue(GrouperClientWs.mostRecentRequest,
8140           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
8141       assertTrue(GrouperClientWs.mostRecentRequest,
8142           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
8143       assertTrue(GrouperClientWs.mostRecentRequest,
8144           !GrouperClientWs.mostRecentRequest.contains("params"));
8145       assertTrue(GrouperClientWs.mostRecentRequest,
8146           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
8147       assertTrue(GrouperClientWs.mostRecentRequest,
8148           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
8149 
8150       // #######################################################
8151       // try includeSubjectDetail
8152 
8153       baos = new ByteArrayOutputStream();
8154       System.setOut(new PrintStream(baos));
8155 
8156       GrouperClient
8157           .main(GrouperClientUtils
8158               .splitTrim(
8159                   "--operation=getMembershipsWs --groupNames=aStem:aGroup,aStem:aGroup2 --includeSubjectDetail=true",
8160                   " "));
8161       System.out.flush();
8162       output = new String(baos.toByteArray());
8163 
8164       System.setOut(systemOut);
8165 
8166       outputLines = GrouperClientUtils.splitTrim(output, "\n");
8167 
8168       assertEquals(4, GrouperUtil.length(outputLines));
8169 
8170       assertTrue(GrouperClientWs.mostRecentRequest,
8171           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
8172       assertTrue(GrouperClientWs.mostRecentRequest,
8173           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
8174       assertTrue(GrouperClientWs.mostRecentRequest,
8175           GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
8176       assertTrue(GrouperClientWs.mostRecentRequest,
8177           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
8178       assertTrue(GrouperClientWs.mostRecentRequest,
8179           !GrouperClientWs.mostRecentRequest.contains("params"));
8180       assertTrue(GrouperClientWs.mostRecentRequest,
8181           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
8182       assertTrue(GrouperClientWs.mostRecentRequest,
8183           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
8184 
8185       // #######################################################
8186       // try subjectAttributeNames
8187 
8188       baos = new ByteArrayOutputStream();
8189       System.setOut(new PrintStream(baos));
8190 
8191       GrouperClient
8192           .main(GrouperClientUtils
8193               .splitTrim(
8194                   "--operation=getMembershipsWs --groupNames=aStem:aGroup,aStem:aGroup2 --subjectAttributeNames=name",
8195                   " "));
8196       System.out.flush();
8197       output = new String(baos.toByteArray());
8198 
8199       System.setOut(systemOut);
8200 
8201       outputLines = GrouperClientUtils.splitTrim(output, "\n");
8202 
8203       assertEquals(4, GrouperUtil.length(outputLines));
8204 
8205       assertTrue(GrouperClientWs.mostRecentRequest,
8206           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
8207       assertTrue(GrouperClientWs.mostRecentRequest,
8208           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
8209       assertTrue(GrouperClientWs.mostRecentRequest,
8210           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
8211       assertTrue(GrouperClientWs.mostRecentRequest,
8212           GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
8213       assertTrue(GrouperClientWs.mostRecentRequest,
8214           !GrouperClientWs.mostRecentRequest.contains("params"));
8215       assertTrue(GrouperClientWs.mostRecentRequest,
8216           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
8217       assertTrue(GrouperClientWs.mostRecentRequest,
8218           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
8219 
8220       // #######################################################
8221       // try params
8222 
8223       baos = new ByteArrayOutputStream();
8224       System.setOut(new PrintStream(baos));
8225 
8226       GrouperClient
8227           .main(GrouperClientUtils
8228               .splitTrim(
8229                   "--operation=getMembershipsWs --groupNames=aStem:aGroup,aStem:aGroup2 --paramName0=someParam --paramValue0=someValue",
8230                   " "));
8231       System.out.flush();
8232       output = new String(baos.toByteArray());
8233 
8234       System.setOut(systemOut);
8235 
8236       outputLines = GrouperClientUtils.splitTrim(output, "\n");
8237 
8238       assertEquals(4, GrouperUtil.length(outputLines));
8239 
8240       assertTrue(GrouperClientWs.mostRecentRequest,
8241           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
8242       assertTrue(GrouperClientWs.mostRecentRequest,
8243           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
8244       assertTrue(GrouperClientWs.mostRecentRequest,
8245           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
8246       assertTrue(GrouperClientWs.mostRecentRequest,
8247           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
8248       assertTrue(GrouperClientWs.mostRecentRequest,
8249           GrouperClientWs.mostRecentRequest.contains("someParam")
8250               && GrouperClientWs.mostRecentRequest.toLowerCase().contains(
8251                   "params")
8252               && GrouperClientWs.mostRecentRequest.contains("someValue"));
8253       assertTrue(GrouperClientWs.mostRecentRequest,
8254           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
8255       assertTrue(GrouperClientWs.mostRecentRequest,
8256           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
8257 
8258       // #######################################################
8259       // try fieldName
8260 
8261       baos = new ByteArrayOutputStream();
8262       System.setOut(new PrintStream(baos));
8263 
8264       GrouperClient
8265           .main(GrouperClientUtils
8266               .splitTrim(
8267                   "--operation=getMembershipsWs --groupNames=aStem:aGroup,aStem:aGroup2 --fieldName=members",
8268                   " "));
8269       System.out.flush();
8270       output = new String(baos.toByteArray());
8271 
8272       System.setOut(systemOut);
8273 
8274       outputLines = GrouperClientUtils.splitTrim(output, "\n");
8275 
8276       assertEquals(4, GrouperUtil.length(outputLines));
8277 
8278       assertTrue(GrouperClientWs.mostRecentRequest,
8279           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
8280       assertTrue(GrouperClientWs.mostRecentRequest,
8281           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
8282       assertTrue(GrouperClientWs.mostRecentRequest,
8283           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
8284       assertTrue(GrouperClientWs.mostRecentRequest,
8285           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
8286       assertTrue(GrouperClientWs.mostRecentRequest,
8287           !GrouperClientWs.mostRecentRequest.contains("params"));
8288       assertTrue(GrouperClientWs.mostRecentRequest,
8289           GrouperClientWs.mostRecentRequest.contains("fieldName")
8290               && GrouperClientWs.mostRecentRequest.contains("members"));
8291       assertTrue(GrouperClientWs.mostRecentRequest,
8292           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
8293 
8294       // #######################################################
8295       // try actAsSubject
8296 
8297       baos = new ByteArrayOutputStream();
8298       System.setOut(new PrintStream(baos));
8299 
8300       GrouperClient
8301           .main(GrouperClientUtils
8302               .splitTrim(
8303                   "--operation=getMembershipsWs --groupNames=aStem:aGroup,aStem:aGroup2 --actAsSubjectId=GrouperSystem",
8304                   " "));
8305       System.out.flush();
8306       output = new String(baos.toByteArray());
8307 
8308       System.setOut(systemOut);
8309 
8310       outputLines = GrouperClientUtils.splitTrim(output, "\n");
8311 
8312       assertEquals(4, GrouperUtil.length(outputLines));
8313 
8314       assertTrue(GrouperClientWs.mostRecentRequest,
8315           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
8316       assertTrue(GrouperClientWs.mostRecentRequest,
8317           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
8318       assertTrue(GrouperClientWs.mostRecentRequest,
8319           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
8320       assertTrue(GrouperClientWs.mostRecentRequest,
8321           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
8322       assertTrue(GrouperClientWs.mostRecentRequest,
8323           !GrouperClientWs.mostRecentRequest.contains("params"));
8324       assertTrue(GrouperClientWs.mostRecentRequest,
8325           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
8326       assertTrue(GrouperClientWs.mostRecentRequest,
8327           GrouperClientWs.mostRecentRequest.contains("actAsSubject")
8328               && GrouperClientWs.mostRecentRequest.contains("GrouperSystem"));
8329 
8330       // #######################################################
8331       // try actAsSubject but with alias
8332 
8333       baos = new ByteArrayOutputStream();
8334       System.setOut(new PrintStream(baos));
8335 
8336       GrouperClient
8337           .main(GrouperClientUtils
8338               .splitTrim(
8339                   "--operation=getMembershipsWs --groupNames=aStem:aGroup,aStem:aGroup2 --actAsPennId=GrouperSystem",
8340                   " "));
8341       System.out.flush();
8342       output = new String(baos.toByteArray());
8343 
8344       System.setOut(systemOut);
8345 
8346       outputLines = GrouperClientUtils.splitTrim(output, "\n");
8347 
8348       assertEquals(4, GrouperUtil.length(outputLines));
8349 
8350       assertTrue(GrouperClientWs.mostRecentRequest,
8351           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
8352       assertTrue(GrouperClientWs.mostRecentRequest,
8353           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
8354       assertTrue(GrouperClientWs.mostRecentRequest,
8355           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
8356       assertTrue(GrouperClientWs.mostRecentRequest,
8357           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
8358       assertTrue(GrouperClientWs.mostRecentRequest,
8359           !GrouperClientWs.mostRecentRequest.contains("params"));
8360       assertTrue(GrouperClientWs.mostRecentRequest,
8361           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
8362       assertTrue(GrouperClientWs.mostRecentRequest,
8363           GrouperClientWs.mostRecentRequest.contains("actAsSubject")
8364               && GrouperClientWs.mostRecentRequest.contains("GrouperSystem"));
8365       assertTrue(GrouperClientWs.mostRecentRequest,
8366           !GrouperClientWs.mostRecentRequest.contains("enabled"));
8367       assertTrue(GrouperClientWs.mostRecentRequest,
8368           !GrouperClientWs.mostRecentRequest.contains("membershipIds"));
8369       assertTrue(GrouperClientWs.mostRecentRequest,
8370           !GrouperClientWs.mostRecentRequest.contains("scope"));
8371       //subjectSources
8372       assertTrue(GrouperClientWs.mostRecentRequest,
8373           !GrouperClientWs.mostRecentRequest.contains("sourceIds"));
8374       assertTrue(GrouperClientWs.mostRecentRequest,
8375           !GrouperClientWs.mostRecentRequest.contains("membershipIds"));
8376       assertTrue(GrouperClientWs.mostRecentRequest,
8377           !GrouperClientWs.mostRecentRequest.contains("wsStemLookup"));
8378       assertTrue(GrouperClientWs.mostRecentRequest,
8379           !GrouperClientWs.mostRecentRequest.contains("stemScope"));
8380       assertTrue(GrouperClientWs.mostRecentRequest,
8381           !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookup"));
8382 
8383 
8384       // #######################################################
8385       // try enabled
8386 
8387       baos = new ByteArrayOutputStream();
8388       System.setOut(new PrintStream(baos));
8389 
8390       GrouperClient
8391           .main(GrouperClientUtils
8392               .splitTrim(
8393                   "--operation=getMembershipsWs --groupNames=aStem:aGroup,aStem:aGroup2 --enabled=F",
8394                   " "));
8395       System.out.flush();
8396       output = new String(baos.toByteArray());
8397 
8398       System.setOut(systemOut);
8399 
8400       outputLines = GrouperClientUtils.splitTrim(output, "\n");
8401 
8402       assertEquals(0, GrouperUtil.length(outputLines));
8403 
8404       assertTrue(GrouperClientWs.mostRecentRequest,
8405           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
8406       assertTrue(GrouperClientWs.mostRecentRequest,
8407           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
8408       assertTrue(GrouperClientWs.mostRecentRequest,
8409           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
8410       assertTrue(GrouperClientWs.mostRecentRequest,
8411           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
8412       assertTrue(GrouperClientWs.mostRecentRequest,
8413           !GrouperClientWs.mostRecentRequest.contains("params"));
8414       assertTrue(GrouperClientWs.mostRecentRequest,
8415           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
8416       assertTrue(GrouperClientWs.mostRecentRequest,
8417           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
8418       assertTrue(GrouperClientWs.mostRecentRequest,
8419           GrouperClientWs.mostRecentRequest.contains("enabled"));
8420       assertTrue(GrouperClientWs.mostRecentRequest,
8421           !GrouperClientWs.mostRecentRequest.contains("membershipIds"));
8422       assertTrue(GrouperClientWs.mostRecentRequest,
8423           !GrouperClientWs.mostRecentRequest.contains("scope"));
8424       //subjectSources
8425       assertTrue(GrouperClientWs.mostRecentRequest,
8426           !GrouperClientWs.mostRecentRequest.contains("sourceIds"));
8427       assertTrue(GrouperClientWs.mostRecentRequest,
8428           !GrouperClientWs.mostRecentRequest.contains("membershipIds"));
8429       assertTrue(GrouperClientWs.mostRecentRequest,
8430           !GrouperClientWs.mostRecentRequest.contains("wsStemLookup"));
8431       assertTrue(GrouperClientWs.mostRecentRequest,
8432           !GrouperClientWs.mostRecentRequest.contains("stemScope"));
8433       assertTrue(GrouperClientWs.mostRecentRequest,
8434           !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookup"));
8435 
8436       // #######################################################
8437       // try all in subtree
8438 
8439       baos = new ByteArrayOutputStream();
8440       System.setOut(new PrintStream(baos));
8441 
8442       GrouperClient
8443           .main(GrouperClientUtils
8444               .splitTrim(
8445                   "--operation=getMembershipsWs --subjectIds=test.subject.0,test.subject.1",
8446                   " "));
8447       System.out.flush();
8448       output = new String(baos.toByteArray());
8449 
8450       System.setOut(systemOut);
8451 
8452       outputLines = GrouperClientUtils.splitTrim(output, "\n");
8453 
8454       assertEquals(2, GrouperUtil.length(outputLines));
8455 
8456       assertTrue(GrouperClientWs.mostRecentRequest,
8457           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
8458       assertTrue(GrouperClientWs.mostRecentRequest,
8459           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
8460       assertTrue(GrouperClientWs.mostRecentRequest,
8461           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
8462       assertTrue(GrouperClientWs.mostRecentRequest,
8463           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
8464       assertTrue(GrouperClientWs.mostRecentRequest,
8465           !GrouperClientWs.mostRecentRequest.contains("params"));
8466       assertTrue(GrouperClientWs.mostRecentRequest,
8467           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
8468       assertTrue(GrouperClientWs.mostRecentRequest,
8469           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
8470       assertTrue(GrouperClientWs.mostRecentRequest,
8471           !GrouperClientWs.mostRecentRequest.contains("enabled"));
8472       assertTrue(GrouperClientWs.mostRecentRequest,
8473           !GrouperClientWs.mostRecentRequest.contains("membershipIds"));
8474       assertTrue(GrouperClientWs.mostRecentRequest,
8475           !GrouperClientWs.mostRecentRequest.contains("scope"));
8476       //subjectSources
8477       assertTrue(GrouperClientWs.mostRecentRequest,
8478           !GrouperClientWs.mostRecentRequest.contains("sourceIds"));
8479       assertTrue(GrouperClientWs.mostRecentRequest,
8480           !GrouperClientWs.mostRecentRequest.contains("membershipIds"));
8481       assertTrue(GrouperClientWs.mostRecentRequest,
8482           !GrouperClientWs.mostRecentRequest.contains("wsStemLookup"));
8483       assertTrue(GrouperClientWs.mostRecentRequest,
8484           !GrouperClientWs.mostRecentRequest.contains("stemScope"));
8485       assertTrue(GrouperClientWs.mostRecentRequest,
8486           !GrouperClientWs.mostRecentRequest.contains("ALL_IN_SUBTREE"));
8487       assertTrue(GrouperClientWs.mostRecentRequest,
8488           GrouperClientWs.mostRecentRequest.contains("wsSubjectLookup"));
8489 
8490       // #######################################################
8491       // try privs in a group
8492 
8493       //group.grantPriv(SubjectTestHelper.SUBJ7, AccessPrivilege.UPDATE, false);
8494       //group.grantPriv(SubjectTestHelper.SUBJ8, AccessPrivilege.ADMIN, false);
8495       //group2.grantPriv(SubjectTestHelper.SUBJ7, AccessPrivilege.UPDATE, false);
8496       //group2.grantPriv(SubjectTestHelper.SUBJ8, AccessPrivilege.ADMIN, false);
8497       //
8498       //stem.grantPriv(SubjectTestHelper.SUBJ7, NamingPrivilege.CREATE, false);
8499       //stem.grantPriv(SubjectTestHelper.SUBJ7, NamingPrivilege.STEM, false);
8500       //stem2.grantPriv(SubjectTestHelper.SUBJ8, NamingPrivilege.CREATE, false);
8501       //stem2.grantPriv(SubjectTestHelper.SUBJ8, NamingPrivilege.STEM, false);
8502       //
8503       //attributeDef.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ7, AttributeDefPrivilege.ATTR_READ, false);
8504       //attributeDef.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ8, AttributeDefPrivilege.ATTR_UPDATE, false);
8505       //attributeDef2.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ7, AttributeDefPrivilege.ATTR_READ, false);
8506       //attributeDef2.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ8, AttributeDefPrivilege.ATTR_UPDATE, false);
8507 
8508       // match: ^Index: (\d+)\: type: group, ownerName\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
8509       // match:  Index: 0: group: aStem:aGroup, subject: test.subject.7, list: updaters, type: immediate, enabled: T
8510       pattern = Pattern
8511           .compile("^Index: (\\d+)\\: (group|folder)\\: (.+), subject\\: (.+), list: (.+), type\\: (.+), enabled\\: (T|F)$");
8512 
8513       baos = new ByteArrayOutputStream();
8514       System.setOut(new PrintStream(baos));
8515 
8516       GrouperClient
8517           .main(GrouperClientUtils
8518               .splitTrim(
8519                   "--operation=getMembershipsWs --subjectIds=test.subject.7,test.subject.8 --fieldType=access",
8520                   " "));
8521       System.out.flush();
8522       output = new String(baos.toByteArray());
8523 
8524       System.setOut(systemOut);
8525 
8526       outputLines = GrouperClientUtils.splitTrim(output, "\n");
8527 
8528       assertEquals(4, GrouperUtil.length(outputLines));
8529 
8530       outputLine = outputLines[0];
8531 
8532       matcher = pattern.matcher(outputLine);
8533 
8534       assertTrue(outputLine, matcher.matches());
8535       assertEquals(outputLine, "0", matcher.group(1));
8536       assertEquals(outputLine, "group", matcher.group(2));
8537       assertEquals(outputLine, "aStem:aGroup", matcher.group(3));
8538       assertEquals(outputLine, "test.subject.7", matcher.group(4));
8539       assertEquals(outputLine, "updaters", matcher.group(5));
8540       assertEquals(outputLine, "immediate", matcher.group(6));
8541       assertEquals(outputLine, "T", matcher.group(7));
8542 
8543       outputLine = outputLines[1];
8544 
8545       matcher = pattern.matcher(outputLine);
8546 
8547       assertTrue(outputLine, matcher.matches());
8548 
8549       assertEquals(outputLine, "1", matcher.group(1));
8550       assertEquals(outputLine, "group", matcher.group(2));
8551       assertEquals(outputLine, "aStem:aGroup", matcher.group(3));
8552       assertEquals(outputLine, "test.subject.8", matcher.group(4));
8553       assertEquals(outputLine, "admins", matcher.group(5));
8554       assertEquals(outputLine, "immediate", matcher.group(6));
8555       assertEquals(outputLine, "T", matcher.group(7));
8556 
8557       outputLine = outputLines[2];
8558 
8559       matcher = pattern.matcher(outputLine);
8560 
8561       assertTrue(outputLine, matcher.matches());
8562 
8563       assertEquals(outputLine, "2", matcher.group(1));
8564       assertEquals(outputLine, "group", matcher.group(2));
8565       assertEquals(outputLine, "aStem:aGroup2", matcher.group(3));
8566       assertEquals(outputLine, "test.subject.7", matcher.group(4));
8567       assertEquals(outputLine, "updaters", matcher.group(5));
8568       assertEquals(outputLine, "immediate", matcher.group(6));
8569       assertEquals(outputLine, "T", matcher.group(7));
8570 
8571       outputLine = outputLines[3];
8572 
8573       matcher = pattern.matcher(outputLine);
8574 
8575       assertTrue(outputLine, matcher.matches());
8576 
8577       assertEquals(outputLine, "3", matcher.group(1));
8578       assertEquals(outputLine, "group", matcher.group(2));
8579       assertEquals(outputLine, "aStem:aGroup2", matcher.group(3));
8580       assertEquals(outputLine, "test.subject.8", matcher.group(4));
8581       assertEquals(outputLine, "admins", matcher.group(5));
8582       assertEquals(outputLine, "immediate", matcher.group(6));
8583       assertEquals(outputLine, "T", matcher.group(7));
8584 
8585       assertTrue(GrouperClientWs.mostRecentRequest,
8586           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
8587       assertTrue(GrouperClientWs.mostRecentRequest,
8588           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
8589       assertTrue(GrouperClientWs.mostRecentRequest,
8590           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
8591       assertTrue(GrouperClientWs.mostRecentRequest,
8592           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
8593       assertTrue(GrouperClientWs.mostRecentRequest,
8594           !GrouperClientWs.mostRecentRequest.contains("params"));
8595       assertTrue(GrouperClientWs.mostRecentRequest,
8596           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
8597       assertTrue(GrouperClientWs.mostRecentRequest,
8598           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
8599       assertTrue(GrouperClientWs.mostRecentRequest,
8600           !GrouperClientWs.mostRecentRequest.contains("enabled"));
8601       assertTrue(GrouperClientWs.mostRecentRequest,
8602           !GrouperClientWs.mostRecentRequest.contains("membershipIds"));
8603       assertTrue(GrouperClientWs.mostRecentRequest,
8604           !GrouperClientWs.mostRecentRequest.contains("scope"));
8605       //subjectSources
8606       assertTrue(GrouperClientWs.mostRecentRequest,
8607           !GrouperClientWs.mostRecentRequest.contains("sourceIds"));
8608       assertTrue(GrouperClientWs.mostRecentRequest,
8609           !GrouperClientWs.mostRecentRequest.contains("membershipIds"));
8610       assertTrue(GrouperClientWs.mostRecentRequest,
8611           !GrouperClientWs.mostRecentRequest.contains("wsStemLookup"));
8612       assertTrue(GrouperClientWs.mostRecentRequest,
8613           !GrouperClientWs.mostRecentRequest.contains("stemScope"));
8614       assertTrue(GrouperClientWs.mostRecentRequest,
8615           !GrouperClientWs.mostRecentRequest.contains("ALL_IN_SUBTREE"));
8616       assertTrue(GrouperClientWs.mostRecentRequest,
8617           GrouperClientWs.mostRecentRequest.contains("wsSubjectLookup"));
8618       assertTrue(GrouperClientWs.mostRecentRequest,
8619           GrouperClientWs.mostRecentRequest.contains("fieldType"));
8620       assertTrue(GrouperClientWs.mostRecentRequest,
8621           GrouperClientWs.mostRecentRequest.contains("access"));
8622 
8623       // #######################################################
8624       // try one level stem
8625 
8626       baos = new ByteArrayOutputStream();
8627       System.setOut(new PrintStream(baos));
8628 
8629       GrouperClient
8630           .main(GrouperClientUtils
8631               .splitTrim(
8632                   "--operation=getMembershipsWs --subjectIds=test.subject.7,test.subject.8 --fieldType=naming --stemIdIndex=" + aStem.getParentStem().getIdIndex() + " --stemScope=ONE_LEVEL",
8633                   " "));
8634       System.out.flush();
8635       output = new String(baos.toByteArray());
8636 
8637       System.setOut(systemOut);
8638 
8639       outputLines = GrouperClientUtils.splitTrim(output, "\n");
8640 
8641       assertEquals(output, 4, GrouperUtil.length(outputLines));
8642 
8643       outputLine = outputLines[0];
8644 
8645       matcher = pattern.matcher(outputLine);
8646 
8647       assertTrue(outputLine, matcher.matches());
8648       assertEquals(outputLine, "0", matcher.group(1));
8649       assertEquals(outputLine, "folder", matcher.group(2));
8650       assertEquals(outputLine, "aStem1", matcher.group(3));
8651       assertEquals(outputLine, "test.subject.7", matcher.group(4));
8652       assertEquals(outputLine, "creators", matcher.group(5));
8653       assertEquals(outputLine, "immediate", matcher.group(6));
8654       assertEquals(outputLine, "T", matcher.group(7));
8655 
8656       outputLine = outputLines[1];
8657 
8658       matcher = pattern.matcher(outputLine);
8659 
8660       assertTrue(outputLine, matcher.matches());
8661 
8662       assertEquals(outputLine, "1", matcher.group(1));
8663       assertEquals(outputLine, "folder", matcher.group(2));
8664       assertEquals(outputLine, "aStem1", matcher.group(3));
8665       assertEquals(outputLine, "test.subject.8", matcher.group(4));
8666       assertEquals(outputLine, "stemAdmins", matcher.group(5));
8667       assertEquals(outputLine, "immediate", matcher.group(6));
8668       assertEquals(outputLine, "T", matcher.group(7));
8669 
8670       outputLine = outputLines[2];
8671 
8672       matcher = pattern.matcher(outputLine);
8673 
8674       assertTrue(outputLine, matcher.matches());
8675 
8676       assertEquals(outputLine, "2", matcher.group(1));
8677       assertEquals(outputLine, "folder", matcher.group(2));
8678       assertEquals(outputLine, "aStem2", matcher.group(3));
8679       assertEquals(outputLine, "test.subject.7", matcher.group(4));
8680       assertEquals(outputLine, "creators", matcher.group(5));
8681       assertEquals(outputLine, "immediate", matcher.group(6));
8682       assertEquals(outputLine, "T", matcher.group(7));
8683 
8684       outputLine = outputLines[3];
8685 
8686       matcher = pattern.matcher(outputLine);
8687 
8688       assertTrue(outputLine, matcher.matches());
8689 
8690       assertEquals(outputLine, "3", matcher.group(1));
8691       assertEquals(outputLine, "folder", matcher.group(2));
8692       assertEquals(outputLine, "aStem2", matcher.group(3));
8693       assertEquals(outputLine, "test.subject.8", matcher.group(4));
8694       assertEquals(outputLine, "stemAdmins", matcher.group(5));
8695       assertEquals(outputLine, "immediate", matcher.group(6));
8696       assertEquals(outputLine, "T", matcher.group(7));
8697 
8698       assertTrue(GrouperClientWs.mostRecentRequest,
8699           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
8700       assertTrue(GrouperClientWs.mostRecentRequest,
8701           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
8702       assertTrue(GrouperClientWs.mostRecentRequest,
8703           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
8704       assertTrue(GrouperClientWs.mostRecentRequest,
8705           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
8706       assertTrue(GrouperClientWs.mostRecentRequest,
8707           !GrouperClientWs.mostRecentRequest.contains("params"));
8708       assertTrue(GrouperClientWs.mostRecentRequest,
8709           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
8710       assertTrue(GrouperClientWs.mostRecentRequest,
8711           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
8712       assertTrue(GrouperClientWs.mostRecentRequest,
8713           !GrouperClientWs.mostRecentRequest.contains("enabled"));
8714       assertTrue(GrouperClientWs.mostRecentRequest,
8715           !GrouperClientWs.mostRecentRequest.contains("membershipIds"));
8716       assertTrue(GrouperClientWs.mostRecentRequest,
8717           !GrouperClientWs.mostRecentRequest.contains("scope"));
8718       //subjectSources
8719       assertTrue(GrouperClientWs.mostRecentRequest,
8720           !GrouperClientWs.mostRecentRequest.contains("sourceIds"));
8721       assertTrue(GrouperClientWs.mostRecentRequest,
8722           !GrouperClientWs.mostRecentRequest.contains("membershipIds"));
8723       assertTrue(GrouperClientWs.mostRecentRequest,
8724           GrouperClientWs.mostRecentRequest.contains("wsStemLookup"));
8725       assertTrue(GrouperClientWs.mostRecentRequest,
8726           GrouperClientWs.mostRecentRequest.contains("stemScope"));
8727       assertTrue(GrouperClientWs.mostRecentRequest,
8728           !GrouperClientWs.mostRecentRequest.contains("ALL_IN_SUBTREE"));
8729       assertTrue(GrouperClientWs.mostRecentRequest,
8730           GrouperClientWs.mostRecentRequest.contains("idIndex"));
8731       assertTrue(GrouperClientWs.mostRecentRequest,
8732           GrouperClientWs.mostRecentRequest.contains("wsSubjectLookup"));
8733       assertTrue(GrouperClientWs.mostRecentRequest,
8734           GrouperClientWs.mostRecentRequest.contains("ONE_LEVEL"));
8735       assertTrue(GrouperClientWs.mostRecentRequest,
8736           GrouperClientWs.mostRecentRequest.contains("naming"));
8737 
8738       // #######################################################
8739       // try privs in a stem
8740 
8741       //stem.grantPriv(SubjectTestHelper.SUBJ7, NamingPrivilege.CREATE, false);
8742       //stem.grantPriv(SubjectTestHelper.SUBJ7, NamingPrivilege.STEM, false);
8743       //stem2.grantPriv(SubjectTestHelper.SUBJ8, NamingPrivilege.CREATE, false);
8744       //stem2.grantPriv(SubjectTestHelper.SUBJ8, NamingPrivilege.STEM, false);
8745 
8746       baos = new ByteArrayOutputStream();
8747       System.setOut(new PrintStream(baos));
8748 
8749       GrouperClient
8750           .main(GrouperClientUtils
8751               .splitTrim(
8752                   "--operation=getMembershipsWs --subjectIds=test.subject.7,test.subject.8 --fieldType=naming",
8753                   " "));
8754       System.out.flush();
8755       output = new String(baos.toByteArray());
8756 
8757       System.setOut(systemOut);
8758 
8759       outputLines = GrouperClientUtils.splitTrim(output, "\n");
8760 
8761       assertEquals(4, GrouperUtil.length(outputLines));
8762 
8763       outputLine = outputLines[0];
8764 
8765       matcher = pattern.matcher(outputLine);
8766 
8767       assertTrue(outputLine, matcher.matches());
8768       assertEquals(outputLine, "0", matcher.group(1));
8769       assertEquals(outputLine, "folder", matcher.group(2));
8770       assertEquals(outputLine, "aStem1", matcher.group(3));
8771       assertEquals(outputLine, "test.subject.7", matcher.group(4));
8772       assertEquals(outputLine, "creators", matcher.group(5));
8773       assertEquals(outputLine, "immediate", matcher.group(6));
8774       assertEquals(outputLine, "T", matcher.group(7));
8775 
8776       outputLine = outputLines[1];
8777 
8778       matcher = pattern.matcher(outputLine);
8779 
8780       assertTrue(outputLine, matcher.matches());
8781 
8782       assertEquals(outputLine, "1", matcher.group(1));
8783       assertEquals(outputLine, "folder", matcher.group(2));
8784       assertEquals(outputLine, "aStem1", matcher.group(3));
8785       assertEquals(outputLine, "test.subject.8", matcher.group(4));
8786       assertEquals(outputLine, "stemAdmins", matcher.group(5));
8787       assertEquals(outputLine, "immediate", matcher.group(6));
8788       assertEquals(outputLine, "T", matcher.group(7));
8789 
8790       outputLine = outputLines[2];
8791 
8792       matcher = pattern.matcher(outputLine);
8793 
8794       assertTrue(outputLine, matcher.matches());
8795 
8796       assertEquals(outputLine, "2", matcher.group(1));
8797       assertEquals(outputLine, "folder", matcher.group(2));
8798       assertEquals(outputLine, "aStem2", matcher.group(3));
8799       assertEquals(outputLine, "test.subject.7", matcher.group(4));
8800       assertEquals(outputLine, "creators", matcher.group(5));
8801       assertEquals(outputLine, "immediate", matcher.group(6));
8802       assertEquals(outputLine, "T", matcher.group(7));
8803 
8804       outputLine = outputLines[3];
8805 
8806       matcher = pattern.matcher(outputLine);
8807 
8808       assertTrue(outputLine, matcher.matches());
8809 
8810       assertEquals(outputLine, "3", matcher.group(1));
8811       assertEquals(outputLine, "folder", matcher.group(2));
8812       assertEquals(outputLine, "aStem2", matcher.group(3));
8813       assertEquals(outputLine, "test.subject.8", matcher.group(4));
8814       assertEquals(outputLine, "stemAdmins", matcher.group(5));
8815       assertEquals(outputLine, "immediate", matcher.group(6));
8816       assertEquals(outputLine, "T", matcher.group(7));
8817 
8818       assertTrue(GrouperClientWs.mostRecentRequest,
8819           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
8820       assertTrue(GrouperClientWs.mostRecentRequest,
8821           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
8822       assertTrue(GrouperClientWs.mostRecentRequest,
8823           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
8824       assertTrue(GrouperClientWs.mostRecentRequest,
8825           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
8826       assertTrue(GrouperClientWs.mostRecentRequest,
8827           !GrouperClientWs.mostRecentRequest.contains("params"));
8828       assertTrue(GrouperClientWs.mostRecentRequest,
8829           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
8830       assertTrue(GrouperClientWs.mostRecentRequest,
8831           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
8832       assertTrue(GrouperClientWs.mostRecentRequest,
8833           !GrouperClientWs.mostRecentRequest.contains("enabled"));
8834       assertTrue(GrouperClientWs.mostRecentRequest,
8835           !GrouperClientWs.mostRecentRequest.contains("membershipIds"));
8836       assertTrue(GrouperClientWs.mostRecentRequest,
8837           !GrouperClientWs.mostRecentRequest.contains("scope"));
8838       //subjectSources
8839       assertTrue(GrouperClientWs.mostRecentRequest,
8840           !GrouperClientWs.mostRecentRequest.contains("sourceIds"));
8841       assertTrue(GrouperClientWs.mostRecentRequest,
8842           !GrouperClientWs.mostRecentRequest.contains("membershipIds"));
8843       assertTrue(GrouperClientWs.mostRecentRequest,
8844           !GrouperClientWs.mostRecentRequest.contains("wsStemLookup"));
8845       assertTrue(GrouperClientWs.mostRecentRequest,
8846           !GrouperClientWs.mostRecentRequest.contains("stemScope"));
8847       assertTrue(GrouperClientWs.mostRecentRequest,
8848           !GrouperClientWs.mostRecentRequest.contains("ALL_IN_SUBTREE"));
8849       assertTrue(GrouperClientWs.mostRecentRequest,
8850           GrouperClientWs.mostRecentRequest.contains("wsSubjectLookup"));
8851       assertTrue(GrouperClientWs.mostRecentRequest,
8852           GrouperClientWs.mostRecentRequest.contains("fieldType"));
8853       assertTrue(GrouperClientWs.mostRecentRequest,
8854           GrouperClientWs.mostRecentRequest.contains("naming"));
8855 
8856       // #######################################################
8857       // try privs in an attributeDef
8858 
8859       //attributeDef.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ7, AttributeDefPrivilege.ATTR_READ, false);
8860       //attributeDef.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ8, AttributeDefPrivilege.ATTR_UPDATE, false);
8861       //attributeDef2.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ7, AttributeDefPrivilege.ATTR_READ, false);
8862       //attributeDef2.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ8, AttributeDefPrivilege.ATTR_UPDATE, false);
8863 
8864       baos = new ByteArrayOutputStream();
8865       System.setOut(new PrintStream(baos));
8866 
8867       GrouperClient
8868           .main(GrouperClientUtils
8869               .splitTrim(
8870                   "--operation=getMembershipsWs --groupNames=aStem:aGroup,aStem:aGroup2 --stemName=aStem --stemScope=ALL_IN_SUBTREE",
8871                   " "));
8872       System.out.flush();
8873       output = new String(baos.toByteArray());
8874 
8875       System.setOut(systemOut);
8876 
8877       outputLines = GrouperClientUtils.splitTrim(output, "\n");
8878 
8879       assertEquals(4, GrouperUtil.length(outputLines));
8880 
8881       assertTrue(GrouperClientWs.mostRecentRequest,
8882           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
8883       assertTrue(GrouperClientWs.mostRecentRequest,
8884           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
8885       assertTrue(GrouperClientWs.mostRecentRequest,
8886           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
8887       assertTrue(GrouperClientWs.mostRecentRequest,
8888           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
8889       assertTrue(GrouperClientWs.mostRecentRequest,
8890           !GrouperClientWs.mostRecentRequest.contains("params"));
8891       assertTrue(GrouperClientWs.mostRecentRequest,
8892           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
8893       assertTrue(GrouperClientWs.mostRecentRequest,
8894           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
8895       assertTrue(GrouperClientWs.mostRecentRequest,
8896           !GrouperClientWs.mostRecentRequest.contains("enabled"));
8897       assertTrue(GrouperClientWs.mostRecentRequest,
8898           !GrouperClientWs.mostRecentRequest.contains("membershipIds"));
8899       assertTrue(GrouperClientWs.mostRecentRequest,
8900           !GrouperClientWs.mostRecentRequest.contains("scope"));
8901       //subjectSources
8902       assertTrue(GrouperClientWs.mostRecentRequest,
8903           !GrouperClientWs.mostRecentRequest.contains("sourceIds"));
8904       assertTrue(GrouperClientWs.mostRecentRequest,
8905           !GrouperClientWs.mostRecentRequest.contains("membershipIds"));
8906       assertTrue(GrouperClientWs.mostRecentRequest,
8907           GrouperClientWs.mostRecentRequest.contains("wsStemLookup"));
8908       assertTrue(GrouperClientWs.mostRecentRequest,
8909           GrouperClientWs.mostRecentRequest.contains("stemScope"));
8910       assertTrue(GrouperClientWs.mostRecentRequest,
8911           GrouperClientWs.mostRecentRequest.contains("ALL_IN_SUBTREE"));
8912       assertTrue(GrouperClientWs.mostRecentRequest,
8913           !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookup"));
8914       assertTrue(GrouperClientWs.mostRecentRequest,
8915           !GrouperClientWs.mostRecentRequest.contains("fieldType"));
8916       assertTrue(GrouperClientWs.mostRecentRequest,
8917           !GrouperClientWs.mostRecentRequest.contains("attributeDef"));
8918 
8919       // #######################################################
8920       // try all in subtree
8921 
8922       baos = new ByteArrayOutputStream();
8923       System.setOut(new PrintStream(baos));
8924 
8925       GrouperClient
8926           .main(GrouperClientUtils
8927               .splitTrim(
8928                   "--operation=getMembershipsWs --subjectIds=test.subject.0,test.subject.1",
8929                   " "));
8930       System.out.flush();
8931       output = new String(baos.toByteArray());
8932 
8933       System.setOut(systemOut);
8934 
8935       outputLines = GrouperClientUtils.splitTrim(output, "\n");
8936 
8937       assertEquals(2, GrouperUtil.length(outputLines));
8938 
8939       assertTrue(GrouperClientWs.mostRecentRequest,
8940           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
8941       assertTrue(GrouperClientWs.mostRecentRequest,
8942           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
8943       assertTrue(GrouperClientWs.mostRecentRequest,
8944           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
8945       assertTrue(GrouperClientWs.mostRecentRequest,
8946           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
8947       assertTrue(GrouperClientWs.mostRecentRequest,
8948           !GrouperClientWs.mostRecentRequest.contains("params"));
8949       assertTrue(GrouperClientWs.mostRecentRequest,
8950           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
8951       assertTrue(GrouperClientWs.mostRecentRequest,
8952           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
8953       assertTrue(GrouperClientWs.mostRecentRequest,
8954           !GrouperClientWs.mostRecentRequest.contains("enabled"));
8955       assertTrue(GrouperClientWs.mostRecentRequest,
8956           !GrouperClientWs.mostRecentRequest.contains("membershipIds"));
8957       assertTrue(GrouperClientWs.mostRecentRequest,
8958           !GrouperClientWs.mostRecentRequest.contains("scope"));
8959       //subjectSources
8960       assertTrue(GrouperClientWs.mostRecentRequest,
8961           !GrouperClientWs.mostRecentRequest.contains("sourceIds"));
8962       assertTrue(GrouperClientWs.mostRecentRequest,
8963           !GrouperClientWs.mostRecentRequest.contains("membershipIds"));
8964       assertTrue(GrouperClientWs.mostRecentRequest,
8965           !GrouperClientWs.mostRecentRequest.contains("wsStemLookup"));
8966       assertTrue(GrouperClientWs.mostRecentRequest,
8967           !GrouperClientWs.mostRecentRequest.contains("stemScope"));
8968       assertTrue(GrouperClientWs.mostRecentRequest,
8969           !GrouperClientWs.mostRecentRequest.contains("ALL_IN_SUBTREE"));
8970       assertTrue(GrouperClientWs.mostRecentRequest,
8971           GrouperClientWs.mostRecentRequest.contains("wsSubjectLookup"));
8972 
8973 
8974     } finally {
8975       System.setOut(systemOut);
8976     }
8977 
8978   }
8979 
8980   /**
8981    * @throws Exception
8982    */
8983   public void testGetSubjects() throws Exception {
8984 
8985     // make sure group exists
8986     GrouperSession grouperSession = GrouperSession.startRootSession();
8987     Group group = Group.saveGroup(grouperSession, "aStem:aGroup", null,
8988         "aStem:aGroup", "aGroup", null, null, true);
8989     Group group2 = Group.saveGroup(grouperSession, "aStem:aGroup2", null,
8990         "aStem:aGroup2", "aGroup2", null, null, true);
8991 
8992     // give permissions
8993     String wsUserLabel = GrouperClientUtils.propertiesValue(
8994         "grouperClient.webService.user.label", true);
8995     String wsUserString = GrouperClientUtils.propertiesValue(
8996         "grouperClient.webService." + wsUserLabel, true);
8997     Subject wsUser = SubjectFinder.findByIdOrIdentifier(wsUserString, true);
8998 
8999     group.grantPriv(wsUser, AccessPrivilege.READ, false);
9000     group.grantPriv(wsUser, AccessPrivilege.VIEW, false);
9001     group2.grantPriv(wsUser, AccessPrivilege.READ, false);
9002     group2.grantPriv(wsUser, AccessPrivilege.VIEW, false);
9003 
9004     // add some subjects
9005     group.addMember(SubjectTestHelper.SUBJ0, false);
9006     group.addMember(SubjectTestHelper.SUBJ1, false);
9007     group2.addMember(SubjectTestHelper.SUBJ2, false);
9008     group2.addMember(SubjectTestHelper.SUBJ3, false);
9009 
9010     PrintStream systemOut = System.out;
9011 
9012     ByteArrayOutputStream baos = new ByteArrayOutputStream();
9013     System.setOut(new PrintStream(baos));
9014 
9015     try {
9016 
9017       GrouperClient.main(GrouperClientUtils.splitTrim(
9018           "--operation=getSubjectsWs --subjectIds=" + SubjectTestHelper.SUBJ0_ID + "," + SubjectTestHelper.SUBJ1_ID,
9019           " "));
9020       System.out.flush();
9021       String output = new String(baos.toByteArray());
9022 
9023       System.setOut(systemOut);
9024 
9025       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
9026 
9027       assertEquals(2, outputLines.length);
9028 
9029       // match: Index: 0: subject: GrouperSystem
9030       // match: ^Index: (\d+)\: subject\: (.+)$
9031       Pattern pattern = Pattern
9032           .compile("^Index: (\\d+)\\: success: (T|F), code: (.+), subject\\: (.+)$");
9033 
9034       String outputLine = outputLines[0];
9035 
9036       Matcher matcher = pattern.matcher(outputLines[0]);
9037 
9038       assertTrue(outputLine, matcher.matches());
9039       assertEquals(outputLine, "0", matcher.group(1));
9040       assertEquals(outputLine, "T", matcher.group(2));
9041       assertEquals(outputLine, "SUCCESS", matcher.group(3));
9042       assertEquals(outputLine, "test.subject.0", matcher.group(4));
9043 
9044       outputLine = outputLines[1];
9045 
9046       matcher = pattern.matcher(outputLine);
9047 
9048       assertTrue(outputLine, matcher.matches());
9049 
9050       assertEquals(outputLine, "1", matcher.group(1));
9051       assertEquals(outputLine, "T", matcher.group(2));
9052       assertEquals(outputLine, "SUCCESS", matcher.group(3));
9053       assertEquals(outputLine, "test.subject.1", matcher.group(4));
9054 
9055       assertTrue(GrouperClientWs.mostRecentRequest,
9056           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9057       assertTrue(GrouperClientWs.mostRecentRequest,
9058           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9059       assertTrue(GrouperClientWs.mostRecentRequest,
9060           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9061       assertTrue(GrouperClientWs.mostRecentRequest,
9062           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9063       assertTrue(GrouperClientWs.mostRecentRequest,
9064           !GrouperClientWs.mostRecentRequest.contains("params"));
9065       assertTrue(GrouperClientWs.mostRecentRequest,
9066           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9067       assertTrue(GrouperClientWs.mostRecentRequest,
9068           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9069 
9070       // ######################################################
9071       // Try sourceIds
9072 
9073       baos = new ByteArrayOutputStream();
9074       System.setOut(new PrintStream(baos));
9075 
9076       GrouperClient.main(GrouperClientUtils.splitTrim(
9077           "--operation=getSubjectsWs --subjectIds=" + SubjectTestHelper.SUBJ0_ID + "," + SubjectTestHelper.SUBJ1_ID + " --subjectSources=jdbc,g:gsa",
9078           " "));
9079 
9080       System.out.flush();
9081       output = new String(baos.toByteArray());
9082 
9083       System.setOut(systemOut);
9084 
9085       outputLines = GrouperClientUtils.splitTrim(output, "\n");
9086 
9087       assertEquals(output, 2, GrouperUtil.length(outputLines));
9088 
9089       outputLine = outputLines[0];
9090 
9091       matcher = pattern.matcher(outputLines[0]);
9092 
9093       assertTrue(outputLine, matcher.matches());
9094       //since this is a different source, it is first (g:gsa)
9095       assertEquals(outputLine, "0", matcher.group(1));
9096       assertEquals(outputLine, "F", matcher.group(2));
9097       assertEquals(outputLine, "SUBJECT_NOT_FOUND", matcher.group(3));
9098       assertEquals(outputLine, "test.subject.1", matcher.group(4));
9099 
9100       outputLine = outputLines[1];
9101 
9102       matcher = pattern.matcher(outputLine);
9103 
9104       assertTrue(outputLine, matcher.matches());
9105 
9106       assertEquals(outputLine, "1", matcher.group(1));
9107       assertEquals(output, "T", matcher.group(2));
9108       assertEquals(outputLine, "SUCCESS", matcher.group(3));
9109       assertEquals(outputLine, "test.subject.0", matcher.group(4));
9110 
9111       assertTrue(GrouperClientWs.mostRecentRequest,
9112           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9113       assertTrue(GrouperClientWs.mostRecentRequest,
9114           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9115       assertTrue(GrouperClientWs.mostRecentRequest,
9116           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9117       assertTrue(GrouperClientWs.mostRecentRequest,
9118           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9119       assertTrue(GrouperClientWs.mostRecentRequest,
9120           !GrouperClientWs.mostRecentRequest.contains("params"));
9121       assertTrue(GrouperClientWs.mostRecentRequest,
9122           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9123       assertTrue(GrouperClientWs.mostRecentRequest,
9124           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9125 
9126       // ######################################################
9127       // Try sourceId
9128 
9129       baos = new ByteArrayOutputStream();
9130       System.setOut(new PrintStream(baos));
9131 
9132       GrouperClient.main(GrouperClientUtils.splitTrim(
9133           "--operation=getSubjectsWs --subjectIds=" + SubjectTestHelper.SUBJ0_ID + "," + SubjectTestHelper.SUBJ1_ID + " --subjectSources=jdbc",
9134           " "));
9135 
9136       System.out.flush();
9137       output = new String(baos.toByteArray());
9138 
9139       System.setOut(systemOut);
9140 
9141       outputLines = GrouperClientUtils.splitTrim(output, "\n");
9142 
9143       assertEquals(output, 2, GrouperUtil.length(outputLines));
9144 
9145       outputLine = outputLines[0];
9146 
9147       matcher = pattern.matcher(outputLines[0]);
9148 
9149       assertTrue(outputLine, matcher.matches());
9150       assertEquals(outputLine, "0", matcher.group(1));
9151       assertEquals(outputLine, "T", matcher.group(2));
9152       assertEquals(outputLine, "SUCCESS", matcher.group(3));
9153       assertEquals(outputLine, "test.subject.0", matcher.group(4));
9154 
9155       outputLine = outputLines[1];
9156 
9157       matcher = pattern.matcher(outputLine);
9158 
9159       assertTrue(outputLine, matcher.matches());
9160 
9161       assertEquals(outputLine, "1", matcher.group(1));
9162       assertEquals(outputLine, "T", matcher.group(2));
9163       assertEquals(outputLine, "SUCCESS", matcher.group(3));
9164       assertEquals(outputLine, "test.subject.1", matcher.group(4));
9165 
9166       assertTrue(GrouperClientWs.mostRecentRequest,
9167           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9168       assertTrue(GrouperClientWs.mostRecentRequest,
9169           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9170       assertTrue(GrouperClientWs.mostRecentRequest,
9171           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9172       assertTrue(GrouperClientWs.mostRecentRequest,
9173           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9174       assertTrue(GrouperClientWs.mostRecentRequest,
9175           !GrouperClientWs.mostRecentRequest.contains("params"));
9176       assertTrue(GrouperClientWs.mostRecentRequest,
9177           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9178       assertTrue(GrouperClientWs.mostRecentRequest,
9179           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9180 
9181       // ######################################################
9182       // Try sourceId not found
9183 
9184       baos = new ByteArrayOutputStream();
9185       System.setOut(new PrintStream(baos));
9186 
9187       GrouperClient.main(GrouperClientUtils.splitTrim(
9188           "--operation=getSubjectsWs --subjectIds=" + SubjectTestHelper.SUBJ0_ID + "," + SubjectTestHelper.SUBJ1_ID + " --subjectSources=g:gsa",
9189           " "));
9190 
9191       System.out.flush();
9192       output = new String(baos.toByteArray());
9193 
9194       System.setOut(systemOut);
9195 
9196       outputLines = GrouperClientUtils.splitTrim(output, "\n");
9197 
9198       assertEquals(output, 2, GrouperUtil.length(outputLines));
9199 
9200       outputLine = outputLines[0];
9201 
9202       matcher = pattern.matcher(outputLines[0]);
9203 
9204       assertTrue(outputLine, matcher.matches());
9205       assertEquals(outputLine, "0", matcher.group(1));
9206       assertEquals(outputLine, "F", matcher.group(2));
9207       assertEquals(outputLine, "SUBJECT_NOT_FOUND", matcher.group(3));
9208       assertEquals(outputLine, "test.subject.0", matcher.group(4));
9209 
9210       outputLine = outputLines[1];
9211 
9212       matcher = pattern.matcher(outputLine);
9213 
9214       assertTrue(outputLine, matcher.matches());
9215 
9216       assertEquals(outputLine, "1", matcher.group(1));
9217       assertEquals(outputLine, "F", matcher.group(2));
9218       assertEquals(outputLine, "SUBJECT_NOT_FOUND", matcher.group(3));
9219       assertEquals(outputLine, "test.subject.1", matcher.group(4));
9220 
9221       assertTrue(GrouperClientWs.mostRecentRequest,
9222           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9223       assertTrue(GrouperClientWs.mostRecentRequest,
9224           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9225       assertTrue(GrouperClientWs.mostRecentRequest,
9226           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9227       assertTrue(GrouperClientWs.mostRecentRequest,
9228           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9229       assertTrue(GrouperClientWs.mostRecentRequest,
9230           !GrouperClientWs.mostRecentRequest.contains("params"));
9231       assertTrue(GrouperClientWs.mostRecentRequest,
9232           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9233       assertTrue(GrouperClientWs.mostRecentRequest,
9234           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9235 
9236 
9237       //##########################################################
9238       //Try a source id with no results
9239 
9240       baos = new ByteArrayOutputStream();
9241       System.setOut(new PrintStream(baos));
9242 
9243       GrouperClient.main(GrouperClientUtils.splitTrim(
9244           "--operation=getSubjectsWs --subjectIds=" + SubjectTestHelper.SUBJ0_ID + "," + SubjectTestHelper.SUBJ1_ID + " --subjectSources=g:gsa,g:gsa",
9245           " "));
9246 
9247       System.out.flush();
9248       output = new String(baos.toByteArray());
9249 
9250       System.setOut(systemOut);
9251 
9252       outputLines = GrouperClientUtils.splitTrim(output, "\n");
9253 
9254       assertEquals(output, 2, GrouperUtil.length(outputLines));
9255 
9256       outputLine = outputLines[0];
9257 
9258       matcher = pattern.matcher(outputLines[0]);
9259 
9260       assertTrue(outputLine, matcher.matches());
9261       assertEquals(outputLine, "0", matcher.group(1));
9262       assertEquals(outputLine, "F", matcher.group(2));
9263       assertEquals(outputLine, "SUBJECT_NOT_FOUND", matcher.group(3));
9264       assertEquals(outputLine, "test.subject.0", matcher.group(4));
9265 
9266       outputLine = outputLines[1];
9267 
9268       matcher = pattern.matcher(outputLine);
9269 
9270       assertTrue(outputLine, matcher.matches());
9271 
9272       assertEquals(outputLine, "1", matcher.group(1));
9273       assertEquals(outputLine, "F", matcher.group(2));
9274       assertEquals(outputLine, "SUBJECT_NOT_FOUND", matcher.group(3));
9275       assertEquals(outputLine, "test.subject.1", matcher.group(4));
9276 
9277       assertTrue(GrouperClientWs.mostRecentRequest,
9278           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9279       assertTrue(GrouperClientWs.mostRecentRequest,
9280           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9281       assertTrue(GrouperClientWs.mostRecentRequest,
9282           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9283       assertTrue(GrouperClientWs.mostRecentRequest,
9284           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9285       assertTrue(GrouperClientWs.mostRecentRequest,
9286           !GrouperClientWs.mostRecentRequest.contains("params"));
9287       assertTrue(GrouperClientWs.mostRecentRequest,
9288           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9289       assertTrue(GrouperClientWs.mostRecentRequest,
9290           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9291 
9292 
9293       //##########################################################
9294       //Try a identifier
9295 
9296       baos = new ByteArrayOutputStream();
9297       System.setOut(new PrintStream(baos));
9298 
9299       GrouperClient.main(GrouperClientUtils.splitTrim(
9300           "--operation=getSubjectsWs --subjectIdentifiers=id.test.subject.0,id.test.subject.1",
9301           " "));
9302 
9303       System.out.flush();
9304       output = new String(baos.toByteArray());
9305 
9306       System.setOut(systemOut);
9307 
9308       outputLines = GrouperClientUtils.splitTrim(output, "\n");
9309 
9310       assertEquals(output, 2, GrouperUtil.length(outputLines));
9311 
9312       outputLine = outputLines[0];
9313 
9314       matcher = pattern.matcher(outputLines[0]);
9315 
9316       assertTrue(outputLine, matcher.matches());
9317       assertEquals(outputLine, "0", matcher.group(1));
9318       assertEquals(outputLine, "T", matcher.group(2));
9319       assertEquals(outputLine, "SUCCESS", matcher.group(3));
9320       assertEquals(outputLine, "test.subject.0", matcher.group(4));
9321 
9322       outputLine = outputLines[1];
9323 
9324       matcher = pattern.matcher(outputLine);
9325 
9326       assertTrue(outputLine, matcher.matches());
9327 
9328       assertEquals(outputLine, "1", matcher.group(1));
9329       assertEquals(outputLine, "T", matcher.group(2));
9330       assertEquals(outputLine, "SUCCESS", matcher.group(3));
9331       assertEquals(outputLine, "test.subject.1", matcher.group(4));
9332 
9333       assertTrue(GrouperClientWs.mostRecentRequest,
9334           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9335       assertTrue(GrouperClientWs.mostRecentRequest,
9336           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9337       assertTrue(GrouperClientWs.mostRecentRequest,
9338           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9339       assertTrue(GrouperClientWs.mostRecentRequest,
9340           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9341       assertTrue(GrouperClientWs.mostRecentRequest,
9342           !GrouperClientWs.mostRecentRequest.contains("params"));
9343       assertTrue(GrouperClientWs.mostRecentRequest,
9344           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9345       assertTrue(GrouperClientWs.mostRecentRequest,
9346           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9347 
9348 
9349       // ######################################################
9350       // Try filter by group
9351 
9352       baos = new ByteArrayOutputStream();
9353       System.setOut(new PrintStream(baos));
9354 
9355       Group aGroup = GroupFinder.findByName(grouperSession, "aStem:aGroup", true);
9356 
9357       GrouperClient.main(GrouperClientUtils.splitTrim(
9358           "--operation=getSubjectsWs --groupUuid=" + aGroup.getUuid() + " --subjectIds=" + SubjectTestHelper.SUBJ5_ID + "," + SubjectTestHelper.SUBJ6_ID,
9359           " "));
9360 
9361       System.out.flush();
9362       output = new String(baos.toByteArray());
9363 
9364       System.setOut(systemOut);
9365 
9366       outputLines = GrouperClientUtils.splitTrim(output, "\n");
9367 
9368       assertEquals(output, 0, GrouperUtil.length(outputLines));
9369 
9370       // ######################################################
9371       // Try filter by group, success
9372 
9373       baos = new ByteArrayOutputStream();
9374       System.setOut(new PrintStream(baos));
9375 
9376       GrouperClient.main(GrouperClientUtils.splitTrim(
9377           "--operation=getSubjectsWs --groupUuid=" + aGroup.getUuid() + " --subjectIds=" + SubjectTestHelper.SUBJ0_ID + "," + SubjectTestHelper.SUBJ7_ID,
9378           " "));
9379 
9380       System.out.flush();
9381       output = new String(baos.toByteArray());
9382 
9383       System.setOut(systemOut);
9384 
9385       outputLines = GrouperClientUtils.splitTrim(output, "\n");
9386 
9387       assertEquals(1, GrouperUtil.length(outputLines));
9388 
9389       outputLine = outputLines[0];
9390 
9391       matcher = pattern.matcher(outputLines[0]);
9392 
9393       assertTrue(outputLine, matcher.matches());
9394       assertEquals(outputLine, "0", matcher.group(1));
9395       assertEquals(outputLine, "T", matcher.group(2));
9396       assertEquals(outputLine, "SUCCESS", matcher.group(3));
9397       assertEquals(outputLine, "test.subject.0", matcher.group(4));
9398 
9399       assertTrue(GrouperClientWs.mostRecentRequest,
9400           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9401       assertTrue(GrouperClientWs.mostRecentRequest,
9402           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9403       assertTrue(GrouperClientWs.mostRecentRequest,
9404           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9405       assertTrue(GrouperClientWs.mostRecentRequest,
9406           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9407       assertTrue(GrouperClientWs.mostRecentRequest,
9408           !GrouperClientWs.mostRecentRequest.contains("params"));
9409       assertTrue(GrouperClientWs.mostRecentRequest,
9410           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9411       assertTrue(GrouperClientWs.mostRecentRequest,
9412           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9413       assertTrue(GrouperClientWs.mostRecentRequest,
9414           GrouperClientWs.mostRecentRequest.contains("<wsGroupLookup><uuid>"));
9415 
9416       // ######################################################
9417       // Try filter by group, success
9418 
9419       baos = new ByteArrayOutputStream();
9420       System.setOut(new PrintStream(baos));
9421 
9422       GrouperClient.main(GrouperClientUtils.splitTrim(
9423           "--operation=getSubjectsWs --groupIdIndex=" + aGroup.getIdIndex() + " --subjectIds=" + SubjectTestHelper.SUBJ0_ID + "," + SubjectTestHelper.SUBJ7_ID,
9424           " "));
9425 
9426       System.out.flush();
9427       output = new String(baos.toByteArray());
9428 
9429       System.setOut(systemOut);
9430 
9431       outputLines = GrouperClientUtils.splitTrim(output, "\n");
9432 
9433       assertEquals(1, GrouperUtil.length(outputLines));
9434 
9435       outputLine = outputLines[0];
9436 
9437       matcher = pattern.matcher(outputLines[0]);
9438 
9439       assertTrue(outputLine, matcher.matches());
9440       assertEquals(outputLine, "0", matcher.group(1));
9441       assertEquals(outputLine, "T", matcher.group(2));
9442       assertEquals(outputLine, "SUCCESS", matcher.group(3));
9443       assertEquals(outputLine, "test.subject.0", matcher.group(4));
9444 
9445       assertTrue(GrouperClientWs.mostRecentRequest,
9446           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9447       assertTrue(GrouperClientWs.mostRecentRequest,
9448           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9449       assertTrue(GrouperClientWs.mostRecentRequest,
9450           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9451       assertTrue(GrouperClientWs.mostRecentRequest,
9452           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9453       assertTrue(GrouperClientWs.mostRecentRequest,
9454           !GrouperClientWs.mostRecentRequest.contains("params"));
9455       assertTrue(GrouperClientWs.mostRecentRequest,
9456           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9457       assertTrue(GrouperClientWs.mostRecentRequest,
9458           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9459       assertTrue(GrouperClientWs.mostRecentRequest,
9460           GrouperClientWs.mostRecentRequest.contains("<wsGroupLookup><idIndex>"));
9461 
9462       // ######################################################
9463       // Try filter by group, success
9464 
9465       baos = new ByteArrayOutputStream();
9466       System.setOut(new PrintStream(baos));
9467 
9468       GrouperClient.main(GrouperClientUtils.splitTrim(
9469           "--operation=getSubjectsWs --groupName=" + aGroup.getName() + " --subjectIds=" + SubjectTestHelper.SUBJ0_ID + "," + SubjectTestHelper.SUBJ7_ID,
9470           " "));
9471 
9472       System.out.flush();
9473       output = new String(baos.toByteArray());
9474 
9475       System.setOut(systemOut);
9476 
9477       outputLines = GrouperClientUtils.splitTrim(output, "\n");
9478 
9479       assertEquals(1, GrouperUtil.length(outputLines));
9480 
9481       outputLine = outputLines[0];
9482 
9483       matcher = pattern.matcher(outputLines[0]);
9484 
9485       assertTrue(outputLine, matcher.matches());
9486       assertEquals(outputLine, "0", matcher.group(1));
9487       assertEquals(outputLine, "T", matcher.group(2));
9488       assertEquals(outputLine, "SUCCESS", matcher.group(3));
9489       assertEquals(outputLine, "test.subject.0", matcher.group(4));
9490 
9491       assertTrue(GrouperClientWs.mostRecentRequest,
9492           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9493       assertTrue(GrouperClientWs.mostRecentRequest,
9494           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9495       assertTrue(GrouperClientWs.mostRecentRequest,
9496           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9497       assertTrue(GrouperClientWs.mostRecentRequest,
9498           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9499       assertTrue(GrouperClientWs.mostRecentRequest,
9500           !GrouperClientWs.mostRecentRequest.contains("params"));
9501       assertTrue(GrouperClientWs.mostRecentRequest,
9502           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9503       assertTrue(GrouperClientWs.mostRecentRequest,
9504           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9505       assertTrue(GrouperClientWs.mostRecentRequest,
9506           GrouperClientWs.mostRecentRequest.contains("<wsGroupLookup><groupName>"));
9507 
9508       // ######################################################
9509       // Try a subject attribute name with custom template
9510 
9511       baos = new ByteArrayOutputStream();
9512       System.setOut(new PrintStream(baos));
9513 
9514       GrouperClient
9515           .main(GrouperClientUtils
9516               .splitTrim(
9517                   "--operation=getSubjectsWs --subjectIds=" + SubjectTestHelper.SUBJ0_ID + " --subjectAttributeNames=a,name --outputTemplate=${wsSubject.getAttributeValue(1)}$newline$",
9518                   " "));
9519       System.out.flush();
9520       output = new String(baos.toByteArray());
9521 
9522       System.setOut(systemOut);
9523 
9524       outputLines = GrouperClientUtils.splitTrim(output, "\n");
9525 
9526       assertEquals(1, outputLines.length);
9527       assertEquals(outputLines[0], "my name is test.subject.0");
9528 
9529       // #######################################################
9530       // try member filter
9531 
9532       baos = new ByteArrayOutputStream();
9533       System.setOut(new PrintStream(baos));
9534 
9535       GrouperClient
9536           .main(GrouperClientUtils
9537               .splitTrim(
9538                   "--operation=getSubjectsWs --groupName=" + aGroup.getName() + " --subjectIds=" + SubjectTestHelper.SUBJ0_ID + " --memberFilter=Effective",
9539                   " "));
9540       System.out.flush();
9541       output = new String(baos.toByteArray());
9542 
9543       System.setOut(systemOut);
9544 
9545       outputLines = GrouperClientUtils.splitTrim(output, "\n");
9546 
9547       assertEquals(0, GrouperUtil.length(outputLines));
9548 
9549       assertTrue(GrouperClientWs.mostRecentRequest,
9550           GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9551       assertTrue(GrouperClientWs.mostRecentRequest,
9552           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9553       assertTrue(GrouperClientWs.mostRecentRequest,
9554           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9555       assertTrue(GrouperClientWs.mostRecentRequest,
9556           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9557       assertTrue(GrouperClientWs.mostRecentRequest,
9558           !GrouperClientWs.mostRecentRequest.contains("params"));
9559       assertTrue(GrouperClientWs.mostRecentRequest,
9560           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9561       assertTrue(GrouperClientWs.mostRecentRequest,
9562           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9563 
9564       // #######################################################
9565       // try member filter immediate
9566 
9567       baos = new ByteArrayOutputStream();
9568       System.setOut(new PrintStream(baos));
9569 
9570       GrouperClient
9571           .main(GrouperClientUtils
9572               .splitTrim(
9573                   "--operation=getSubjectsWs --groupName=" + aGroup.getName() + " --subjectIds=" + SubjectTestHelper.SUBJ0_ID + " --memberFilter=Immediate",
9574                   " "));
9575       System.out.flush();
9576       output = new String(baos.toByteArray());
9577 
9578       System.setOut(systemOut);
9579 
9580       outputLines = GrouperClientUtils.splitTrim(output, "\n");
9581 
9582       assertEquals(1, GrouperUtil.length(outputLines));
9583 
9584       outputLine = outputLines[0];
9585 
9586       matcher = pattern.matcher(outputLines[0]);
9587 
9588       assertTrue(outputLine, matcher.matches());
9589       assertEquals(outputLine, "0", matcher.group(1));
9590       assertEquals(outputLine, "T", matcher.group(2));
9591       assertEquals(outputLine, "SUCCESS", matcher.group(3));
9592       assertEquals(outputLine, "test.subject.0", matcher.group(4));
9593 
9594       assertTrue(GrouperClientWs.mostRecentRequest,
9595           GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9596       assertTrue(GrouperClientWs.mostRecentRequest,
9597           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9598       assertTrue(GrouperClientWs.mostRecentRequest,
9599           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9600       assertTrue(GrouperClientWs.mostRecentRequest,
9601           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9602       assertTrue(GrouperClientWs.mostRecentRequest,
9603           !GrouperClientWs.mostRecentRequest.contains("params"));
9604       assertTrue(GrouperClientWs.mostRecentRequest,
9605           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9606       assertTrue(GrouperClientWs.mostRecentRequest,
9607           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9608 
9609       // #######################################################
9610       // try includeGroupDetail
9611 
9612       baos = new ByteArrayOutputStream();
9613       System.setOut(new PrintStream(baos));
9614 
9615       GrouperClient
9616           .main(GrouperClientUtils
9617               .splitTrim(
9618                   "--operation=getSubjectsWs --groupName=" + aGroup.getName() + " --subjectIds=" + SubjectTestHelper.SUBJ0_ID + " --includeGroupDetail=true",
9619                   " "));
9620       System.out.flush();
9621       output = new String(baos.toByteArray());
9622 
9623       System.setOut(systemOut);
9624 
9625       outputLines = GrouperClientUtils.splitTrim(output, "\n");
9626 
9627       assertEquals(1, GrouperUtil.length(outputLines));
9628 
9629       assertTrue(GrouperClientWs.mostRecentRequest,
9630           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9631       assertTrue(GrouperClientWs.mostRecentRequest,
9632           GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9633       assertTrue(GrouperClientWs.mostRecentRequest,
9634           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9635       assertTrue(GrouperClientWs.mostRecentRequest,
9636           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9637       assertTrue(GrouperClientWs.mostRecentRequest,
9638           !GrouperClientWs.mostRecentRequest.contains("params"));
9639       assertTrue(GrouperClientWs.mostRecentRequest,
9640           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9641       assertTrue(GrouperClientWs.mostRecentRequest,
9642           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9643 
9644       // #######################################################
9645       // try includeSubjectDetail
9646 
9647       baos = new ByteArrayOutputStream();
9648       System.setOut(new PrintStream(baos));
9649 
9650       GrouperClient
9651           .main(GrouperClientUtils
9652               .splitTrim(
9653                   "--operation=getSubjectsWs --subjectIds=" + SubjectTestHelper.SUBJ0_ID + "  --includeSubjectDetail=true",
9654                   " "));
9655       System.out.flush();
9656       output = new String(baos.toByteArray());
9657 
9658       System.setOut(systemOut);
9659 
9660       outputLines = GrouperClientUtils.splitTrim(output, "\n");
9661 
9662       assertEquals(1, GrouperUtil.length(outputLines));
9663 
9664       assertTrue(GrouperClientWs.mostRecentRequest,
9665           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9666       assertTrue(GrouperClientWs.mostRecentRequest,
9667           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9668       assertTrue(GrouperClientWs.mostRecentRequest,
9669           GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9670       assertTrue(GrouperClientWs.mostRecentRequest,
9671           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9672       assertTrue(GrouperClientWs.mostRecentRequest,
9673           !GrouperClientWs.mostRecentRequest.contains("params"));
9674       assertTrue(GrouperClientWs.mostRecentRequest,
9675           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9676       assertTrue(GrouperClientWs.mostRecentRequest,
9677           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9678 
9679       // #######################################################
9680       // try subjectAttributeNames
9681 
9682       baos = new ByteArrayOutputStream();
9683       System.setOut(new PrintStream(baos));
9684 
9685       GrouperClient
9686           .main(GrouperClientUtils
9687               .splitTrim(
9688                   "--operation=getSubjectsWs --subjectIds=" + SubjectTestHelper.SUBJ0_ID + "  --subjectAttributeNames=name",
9689                   " "));
9690       System.out.flush();
9691       output = new String(baos.toByteArray());
9692 
9693       System.setOut(systemOut);
9694 
9695       outputLines = GrouperClientUtils.splitTrim(output, "\n");
9696 
9697       assertEquals(1, GrouperUtil.length(outputLines));
9698 
9699       assertTrue(GrouperClientWs.mostRecentRequest,
9700           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9701       assertTrue(GrouperClientWs.mostRecentRequest,
9702           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9703       assertTrue(GrouperClientWs.mostRecentRequest,
9704           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9705       assertTrue(GrouperClientWs.mostRecentRequest,
9706           GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9707       assertTrue(GrouperClientWs.mostRecentRequest,
9708           !GrouperClientWs.mostRecentRequest.contains("params"));
9709       assertTrue(GrouperClientWs.mostRecentRequest,
9710           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9711       assertTrue(GrouperClientWs.mostRecentRequest,
9712           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9713 
9714       // #######################################################
9715       // try params
9716 
9717       baos = new ByteArrayOutputStream();
9718       System.setOut(new PrintStream(baos));
9719 
9720       GrouperClient
9721           .main(GrouperClientUtils
9722               .splitTrim(
9723                   "--operation=getSubjectsWs --subjectIds=" + SubjectTestHelper.SUBJ0_ID + "  --paramName0=someParam --paramValue0=someValue",
9724                   " "));
9725       System.out.flush();
9726       output = new String(baos.toByteArray());
9727 
9728       System.setOut(systemOut);
9729 
9730       outputLines = GrouperClientUtils.splitTrim(output, "\n");
9731 
9732       assertEquals(1, GrouperUtil.length(outputLines));
9733 
9734       assertTrue(GrouperClientWs.mostRecentRequest,
9735           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9736       assertTrue(GrouperClientWs.mostRecentRequest,
9737           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9738       assertTrue(GrouperClientWs.mostRecentRequest,
9739           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9740       assertTrue(GrouperClientWs.mostRecentRequest,
9741           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9742       assertTrue(GrouperClientWs.mostRecentRequest,
9743           GrouperClientWs.mostRecentRequest.contains("someParam")
9744               && GrouperClientWs.mostRecentRequest.toLowerCase().contains(
9745                   "params")
9746               && GrouperClientWs.mostRecentRequest.contains("someValue"));
9747       assertTrue(GrouperClientWs.mostRecentRequest,
9748           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9749       assertTrue(GrouperClientWs.mostRecentRequest,
9750           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9751 
9752       // #######################################################
9753       // try fieldName
9754 
9755       baos = new ByteArrayOutputStream();
9756       System.setOut(new PrintStream(baos));
9757 
9758       GrouperClient
9759           .main(GrouperClientUtils
9760               .splitTrim(
9761                   "--operation=getSubjectsWs --groupName=aStem:aGroup --subjectIds=" + SubjectTestHelper.SUBJ0_ID + "  --fieldName=members",
9762                   " "));
9763       System.out.flush();
9764       output = new String(baos.toByteArray());
9765 
9766       System.setOut(systemOut);
9767 
9768       outputLines = GrouperClientUtils.splitTrim(output, "\n");
9769 
9770       assertEquals(1, GrouperUtil.length(outputLines));
9771 
9772       assertTrue(GrouperClientWs.mostRecentRequest,
9773           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9774       assertTrue(GrouperClientWs.mostRecentRequest,
9775           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9776       assertTrue(GrouperClientWs.mostRecentRequest,
9777           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9778       assertTrue(GrouperClientWs.mostRecentRequest,
9779           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9780       assertTrue(GrouperClientWs.mostRecentRequest,
9781           !GrouperClientWs.mostRecentRequest.contains("params"));
9782       assertTrue(GrouperClientWs.mostRecentRequest,
9783           GrouperClientWs.mostRecentRequest.contains("fieldName")
9784               && GrouperClientWs.mostRecentRequest.contains("members"));
9785       assertTrue(GrouperClientWs.mostRecentRequest,
9786           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9787 
9788       // #######################################################
9789       // try actAsSubject
9790 
9791       baos = new ByteArrayOutputStream();
9792       System.setOut(new PrintStream(baos));
9793 
9794       GrouperClient
9795           .main(GrouperClientUtils
9796               .splitTrim(
9797                   "--operation=getSubjectsWs --subjectIds=" + SubjectTestHelper.SUBJ0_ID + "  --actAsSubjectId=GrouperSystem",
9798                   " "));
9799       System.out.flush();
9800       output = new String(baos.toByteArray());
9801 
9802       System.setOut(systemOut);
9803 
9804       outputLines = GrouperClientUtils.splitTrim(output, "\n");
9805 
9806       assertEquals(1, GrouperUtil.length(outputLines));
9807 
9808       assertTrue(GrouperClientWs.mostRecentRequest,
9809           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9810       assertTrue(GrouperClientWs.mostRecentRequest,
9811           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9812       assertTrue(GrouperClientWs.mostRecentRequest,
9813           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9814       assertTrue(GrouperClientWs.mostRecentRequest,
9815           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9816       assertTrue(GrouperClientWs.mostRecentRequest,
9817           !GrouperClientWs.mostRecentRequest.contains("params"));
9818       assertTrue(GrouperClientWs.mostRecentRequest,
9819           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9820       assertTrue(GrouperClientWs.mostRecentRequest,
9821           GrouperClientWs.mostRecentRequest.contains("actAsSubject")
9822               && GrouperClientWs.mostRecentRequest.contains("GrouperSystem"));
9823 
9824       // #######################################################
9825       // try actAsSubject but with alias
9826 
9827       baos = new ByteArrayOutputStream();
9828       System.setOut(new PrintStream(baos));
9829 
9830       GrouperClient
9831           .main(GrouperClientUtils
9832               .splitTrim(
9833                   "--operation=getSubjectsWs --subjectIds=" + SubjectTestHelper.SUBJ0_ID + "  --actAsPennId=GrouperSystem",
9834                   " "));
9835       System.out.flush();
9836       output = new String(baos.toByteArray());
9837 
9838       System.setOut(systemOut);
9839 
9840       outputLines = GrouperClientUtils.splitTrim(output, "\n");
9841 
9842       assertEquals(1, GrouperUtil.length(outputLines));
9843 
9844       assertTrue(GrouperClientWs.mostRecentRequest,
9845           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9846       assertTrue(GrouperClientWs.mostRecentRequest,
9847           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9848       assertTrue(GrouperClientWs.mostRecentRequest,
9849           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9850       assertTrue(GrouperClientWs.mostRecentRequest,
9851           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9852       assertTrue(GrouperClientWs.mostRecentRequest,
9853           !GrouperClientWs.mostRecentRequest.contains("params"));
9854       assertTrue(GrouperClientWs.mostRecentRequest,
9855           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9856       assertTrue(GrouperClientWs.mostRecentRequest,
9857           GrouperClientWs.mostRecentRequest.contains("actAsSubject")
9858               && GrouperClientWs.mostRecentRequest.contains("GrouperSystem"));
9859       //subjectSources
9860       assertTrue(GrouperClientWs.mostRecentRequest,
9861           !GrouperClientWs.mostRecentRequest.contains("sourceIds"));
9862 
9863       // #######################################################
9864       // try searchString
9865 
9866       baos = new ByteArrayOutputStream();
9867       System.setOut(new PrintStream(baos));
9868 
9869       GrouperClient
9870           .main(GrouperClientUtils
9871               .splitTrim(
9872                   "--operation=getSubjectsWs --searchString=test",
9873                   " "));
9874       System.out.flush();
9875       output = new String(baos.toByteArray());
9876 
9877       System.setOut(systemOut);
9878 
9879       outputLines = GrouperClientUtils.splitTrim(output, "\n");
9880 
9881       assertTrue(output, 8 < GrouperUtil.length(outputLines));
9882 
9883       assertTrue(GrouperClientWs.mostRecentRequest,
9884           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9885       assertTrue(GrouperClientWs.mostRecentRequest,
9886           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9887       assertTrue(GrouperClientWs.mostRecentRequest,
9888           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9889       assertTrue(GrouperClientWs.mostRecentRequest,
9890           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9891       assertTrue(GrouperClientWs.mostRecentRequest,
9892           !GrouperClientWs.mostRecentRequest.contains("params"));
9893       assertTrue(GrouperClientWs.mostRecentRequest,
9894           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9895       assertTrue(GrouperClientWs.mostRecentRequest,
9896           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9897       //subjectSources
9898       assertTrue(GrouperClientWs.mostRecentRequest,
9899           !GrouperClientWs.mostRecentRequest.contains("sourceIds"));
9900       assertTrue(GrouperClientWs.mostRecentRequest,
9901           !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookup"));
9902 
9903 
9904       // #######################################################
9905       // try searchString
9906 
9907       baos = new ByteArrayOutputStream();
9908       System.setOut(new PrintStream(baos));
9909 
9910       GrouperClient
9911           .main(GrouperClientUtils
9912               .splitTrim(
9913                   "--operation=getSubjectsWs --searchString=test --sourceIds=jdbc",
9914                   " "));
9915       System.out.flush();
9916       output = new String(baos.toByteArray());
9917 
9918       System.setOut(systemOut);
9919 
9920       outputLines = GrouperClientUtils.splitTrim(output, "\n");
9921 
9922       assertTrue(output, 8 < GrouperUtil.length(outputLines));
9923 
9924       assertTrue(GrouperClientWs.mostRecentRequest,
9925           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9926       assertTrue(GrouperClientWs.mostRecentRequest,
9927           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9928       assertTrue(GrouperClientWs.mostRecentRequest,
9929           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9930       assertTrue(GrouperClientWs.mostRecentRequest,
9931           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9932       assertTrue(GrouperClientWs.mostRecentRequest,
9933           !GrouperClientWs.mostRecentRequest.contains("params"));
9934       assertTrue(GrouperClientWs.mostRecentRequest,
9935           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9936       assertTrue(GrouperClientWs.mostRecentRequest,
9937           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9938       //subjectSources
9939       assertTrue(GrouperClientWs.mostRecentRequest,
9940           GrouperClientWs.mostRecentRequest.contains("sourceIds"));
9941       assertTrue(GrouperClientWs.mostRecentRequest,
9942           !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookup"));
9943 
9944 
9945       // #######################################################
9946       // try subjectSources
9947 
9948       baos = new ByteArrayOutputStream();
9949       System.setOut(new PrintStream(baos));
9950 
9951       GrouperClient
9952           .main(GrouperClientUtils
9953               .splitTrim(
9954                   "--operation=getSubjectsWs --searchString=test --sourceIds=g:gsa",
9955                   " "));
9956       System.out.flush();
9957       output = new String(baos.toByteArray());
9958 
9959       System.setOut(systemOut);
9960 
9961       outputLines = GrouperClientUtils.splitTrim(output, "\n");
9962 
9963       assertEquals(output, 0, GrouperUtil.length(outputLines));
9964 
9965       assertTrue(GrouperClientWs.mostRecentRequest,
9966           !GrouperClientWs.mostRecentRequest.contains("memberFilter"));
9967       assertTrue(GrouperClientWs.mostRecentRequest,
9968           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
9969       assertTrue(GrouperClientWs.mostRecentRequest,
9970           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
9971       assertTrue(GrouperClientWs.mostRecentRequest,
9972           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
9973       assertTrue(GrouperClientWs.mostRecentRequest,
9974           !GrouperClientWs.mostRecentRequest.contains("params"));
9975       assertTrue(GrouperClientWs.mostRecentRequest,
9976           !GrouperClientWs.mostRecentRequest.contains("fieldName"));
9977       assertTrue(GrouperClientWs.mostRecentRequest,
9978           !GrouperClientWs.mostRecentRequest.contains("actAsSubject"));
9979       //subjectSources
9980       assertTrue(GrouperClientWs.mostRecentRequest,
9981           GrouperClientWs.mostRecentRequest.contains("sourceIds"));
9982       assertTrue(GrouperClientWs.mostRecentRequest,
9983           !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookup"));
9984 
9985 
9986 
9987     } finally {
9988       System.setOut(systemOut);
9989     }
9990 
9991   }
9992 
9993   /**
9994    * @throws Exception
9995    */
9996   public void testAssignGrouperPrivileges() throws Exception {
9997 
9998     PrintStream systemOut = System.out;
9999 
10000     ByteArrayOutputStream baos = new ByteArrayOutputStream();
10001     System.setOut(new PrintStream(baos));
10002 
10003     try {
10004 
10005       GrouperClient
10006           .main(GrouperClientUtils
10007               .splitTrim(
10008                   "--operation=assignGrouperPrivilegesWs --groupName=aStem:aGroup --subjectIds=test.subject.0 --privilegeNames=optin --allowed=true",
10009                   " "));
10010       System.out.flush();
10011       String output = new String(baos.toByteArray());
10012 
10013       System.setOut(systemOut);
10014 
10015       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
10016 
10017       Pattern pattern = Pattern
10018           .compile("^Index: ([0-9]+), success: (T|F), code: (.+), (group|stem): (.*), subject: (.+), (.+): (.+)$");
10019       Matcher matcher = pattern.matcher(outputLines[0]);
10020 
10021       assertEquals(output, 1, GrouperClientUtils.length(outputLines));
10022       assertTrue(outputLines[0], matcher.matches());
10023 
10024       assertEquals("0", matcher.group(1));
10025       assertEquals("T", matcher.group(2));
10026       assertEquals("SUCCESS_ALLOWED", matcher.group(3));
10027       assertEquals("group", matcher.group(4));
10028       assertEquals("aStem:aGroup", matcher.group(5));
10029       assertEquals("test.subject.0", matcher.group(6));
10030       assertEquals("access", matcher.group(7));
10031       assertEquals("optin", matcher.group(8));
10032 
10033       // #####################################################
10034       // run again with subject identifier, and privilege type
10035       baos = new ByteArrayOutputStream();
10036       System.setOut(new PrintStream(baos));
10037 
10038       GrouperClient
10039           .main(GrouperClientUtils
10040               .splitTrim(
10041                   "--operation=assignGrouperPrivilegesWs --groupName=aStem:aGroup --subjectIdentifiers=id.test.subject.0 --privilegeType=access --privilegeNames=optin --allowed=true",
10042                   " "));
10043       System.out.flush();
10044       output = new String(baos.toByteArray());
10045 
10046       System.setOut(systemOut);
10047 
10048       outputLines = GrouperClientUtils.splitTrim(output, "\n");
10049 
10050       matcher = pattern.matcher(outputLines[0]);
10051 
10052       assertEquals(GrouperClientUtils.length(outputLines), 1);
10053       assertTrue(outputLines[0], matcher.matches());
10054 
10055       assertEquals("0", matcher.group(1));
10056       assertEquals("T", matcher.group(2));
10057       assertEquals("SUCCESS_ALLOWED_ALREADY_EXISTED", matcher.group(3));
10058       assertEquals("group", matcher.group(4));
10059       assertEquals("aStem:aGroup", matcher.group(5));
10060       assertEquals("test.subject.0", matcher.group(6));
10061       assertEquals("access", matcher.group(7));
10062       assertEquals("optin", matcher.group(8));
10063 
10064       assertTrue(GrouperClientWs.mostRecentRequest,
10065           GrouperClientWs.mostRecentRequest.contains("access")
10066               && GrouperClientWs.mostRecentRequest.contains("privilegeType")
10067               && GrouperClientWs.mostRecentRequest
10068                   .contains("id.test.subject.0"));
10069 
10070       // #####################################################
10071       // run with invalid args
10072       baos = new ByteArrayOutputStream();
10073       System.setOut(new PrintStream(baos));
10074 
10075       // test a command line template
10076       try {
10077         GrouperClient
10078             .main(GrouperClientUtils
10079                 .splitTrim(
10080                     "--operation=assignGrouperPrivilegesWs --groupName=aStem:aGroup --subjectIds=test.subject.0 --privilegeNames=optin --allowed=true --ousdfsdfate=${index}",
10081                     " "));
10082       } catch (Exception e) {
10083         assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
10084       }
10085       System.out.flush();
10086 
10087       System.setOut(systemOut);
10088 
10089       // #####################################################
10090       // run with custom template
10091       baos = new ByteArrayOutputStream();
10092       System.setOut(new PrintStream(baos));
10093 
10094       // test a command line template
10095       GrouperClient
10096           .main(GrouperClientUtils
10097               .splitTrim(
10098                   "--operation=assignGrouperPrivilegesWs --groupName=aStem:aGroup --pennKeys=id.test.subject.0 --privilegeNames=optin --allowed=true --outputTemplate=${wsSubject.identifierLookup}",
10099                   " "));
10100 
10101       System.out.flush();
10102 
10103       output = new String(baos.toByteArray());
10104 
10105       assertEquals("id.test.subject.0", output);
10106 
10107       System.setOut(systemOut);
10108 
10109       // #####################################################
10110       // run again, with stem
10111       baos = new ByteArrayOutputStream();
10112       System.setOut(new PrintStream(baos));
10113 
10114       GrouperClient
10115           .main(GrouperClientUtils
10116               .splitTrim(
10117                   "--operation=assignGrouperPrivilegesWs --stemName=aStem --pennKeys=id.test.subject.0 --privilegeNames=stem --allowed=true",
10118                   " "));
10119       System.out.flush();
10120       output = new String(baos.toByteArray());
10121 
10122       System.setOut(systemOut);
10123 
10124       outputLines = GrouperClientUtils.splitTrim(output, "\n");
10125 
10126       matcher = pattern.matcher(outputLines[0]);
10127 
10128       assertEquals(GrouperClientUtils.length(outputLines), 1);
10129       assertTrue(outputLines[0], matcher.matches());
10130 
10131       assertEquals("0", matcher.group(1));
10132       assertEquals("T", matcher.group(2));
10133       assertEquals("SUCCESS_ALLOWED_ALREADY_EXISTED", matcher.group(3));
10134       assertEquals("stem", matcher.group(4));
10135       assertEquals("aStem", matcher.group(5));
10136       assertEquals("test.subject.0", matcher.group(6));
10137       assertEquals("naming", matcher.group(7));
10138       assertEquals("stemAdmin", matcher.group(8));
10139 
10140       // #####################################################
10141       // run again, with includeGroupDetail and includeSubjectDetail
10142       baos = new ByteArrayOutputStream();
10143       System.setOut(new PrintStream(baos));
10144 
10145       GrouperClient
10146           .main(GrouperClientUtils
10147               .splitTrim(
10148                   "--operation=assignGrouperPrivilegesWs --groupName=aStem:aGroup --subjectIds=test.subject.0 --includeGroupDetail=true --includeSubjectDetail=true --privilegeNames=optin --allowed=false",
10149                   " "));
10150       System.out.flush();
10151       output = new String(baos.toByteArray());
10152 
10153       System.setOut(systemOut);
10154 
10155       outputLines = GrouperClientUtils.splitTrim(output, "\n");
10156 
10157       matcher = pattern.matcher(outputLines[0]);
10158 
10159       assertEquals(GrouperClientUtils.length(outputLines), 1);
10160       assertTrue(outputLines[0], matcher.matches());
10161 
10162       assertEquals("0", matcher.group(1));
10163       assertEquals("T", matcher.group(2));
10164       assertEquals("SUCCESS_NOT_ALLOWED", matcher.group(3));
10165       assertEquals("group", matcher.group(4));
10166       assertEquals("aStem:aGroup", matcher.group(5));
10167       assertEquals("test.subject.0", matcher.group(6));
10168       assertEquals("access", matcher.group(7));
10169       assertEquals("optin", matcher.group(8));
10170 
10171       assertTrue(GrouperClientWs.mostRecentRequest
10172           .contains("includeGroupDetail")
10173           && GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
10174 
10175       // #####################################################
10176       // run again, with subject attributes
10177       baos = new ByteArrayOutputStream();
10178       System.setOut(new PrintStream(baos));
10179 
10180       GrouperClient
10181           .main(GrouperClientUtils
10182               .splitTrim(
10183                   "--operation=assignGrouperPrivilegesWs --groupName=aStem:aGroup --subjectIds=test.subject.0 --subjectAttributeNames=name --privilegeNames=optin --allowed=false --outputTemplate=${index}:$space$${wsSubject.getAttributeValue(0)}$newline$",
10184                   " "));
10185       System.out.flush();
10186       output = new String(baos.toByteArray());
10187 
10188       System.setOut(systemOut);
10189 
10190       outputLines = GrouperClientUtils.splitTrim(output, "\n");
10191 
10192       assertTrue(outputLines[0], outputLines[0]
10193           .contains("my name is test.subject.0"));
10194 
10195       assertTrue(GrouperClientWs.mostRecentRequest.contains(">name<"));
10196       assertTrue(GrouperClientWs.mostRecentResponse
10197           .contains("my name is test.subject.0"));
10198 
10199       // #####################################################
10200       // run again, with params
10201       baos = new ByteArrayOutputStream();
10202       System.setOut(new PrintStream(baos));
10203 
10204       GrouperClient
10205           .main(GrouperClientUtils
10206               .splitTrim(
10207                   "--operation=assignGrouperPrivilegesWs --groupName=aStem:aGroup --privilegeNames=optin --allowed=false --subjectIds=test.subject.0 --paramName0=whatever --paramValue0=someValue",
10208                   " "));
10209       System.out.flush();
10210       output = new String(baos.toByteArray());
10211 
10212       System.setOut(systemOut);
10213 
10214       outputLines = GrouperClientUtils.splitTrim(output, "\n");
10215 
10216       matcher = pattern.matcher(outputLines[0]);
10217 
10218       assertEquals(GrouperClientUtils.length(outputLines), 1);
10219       assertTrue(outputLines[0], matcher.matches());
10220 
10221       assertEquals("0", matcher.group(1));
10222       assertEquals("T", matcher.group(2));
10223       assertEquals("SUCCESS_NOT_ALLOWED_DIDNT_EXIST", matcher.group(3));
10224       assertEquals("group", matcher.group(4));
10225       assertEquals("aStem:aGroup", matcher.group(5));
10226       assertEquals("test.subject.0", matcher.group(6));
10227       assertEquals("access", matcher.group(7));
10228       assertEquals("optin", matcher.group(8));
10229 
10230       assertTrue(GrouperClientWs.mostRecentRequest.contains("whatever")
10231           && GrouperClientWs.mostRecentRequest.contains("someValue"));
10232 
10233       // #####################################################
10234       // run again, replace existing
10235       baos = new ByteArrayOutputStream();
10236       System.setOut(new PrintStream(baos));
10237 
10238       GrouperSession grouperSession = GrouperSession.startRootSession();
10239 
10240       Group replaceGroup = new GroupSave(grouperSession).assignGroupNameToEdit("aStem:replaceExisting")
10241         .assignName("aStem:replaceExisting").assignCreateParentStemsIfNotExist(true).save();
10242 
10243       Set<Subject> subjects = grouperSession.getAccessResolver().getSubjectsWithPrivilege(replaceGroup, AccessPrivilege.UPDATE);
10244 
10245       assertEquals(0, GrouperUtil.length(subjects));
10246 
10247       replaceGroup.grantPriv(SubjectTestHelper.SUBJ0, AccessPrivilege.UPDATE);
10248 
10249       GrouperClient
10250           .main(GrouperClientUtils
10251               .splitTrim(
10252                   "--operation=assignGrouperPrivilegesWs --groupName=aStem:replaceExisting --privilegeNames=update --allowed=true --subjectIds=test.subject.4 --replaceAllExisting=true",
10253                   " "));
10254       System.out.flush();
10255       output = new String(baos.toByteArray());
10256 
10257       System.setOut(systemOut);
10258 
10259       outputLines = GrouperClientUtils.splitTrim(output, "\n");
10260 
10261       matcher = pattern.matcher(outputLines[0]);
10262 
10263       assertEquals(GrouperClientUtils.length(outputLines), 1);
10264       assertTrue(outputLines[0], matcher.matches());
10265 
10266       assertEquals("0", matcher.group(1));
10267       assertEquals("T", matcher.group(2));
10268       assertEquals("SUCCESS_ALLOWED", matcher.group(3));
10269       assertEquals("group", matcher.group(4));
10270       assertEquals("aStem:replaceExisting", matcher.group(5));
10271       assertEquals("test.subject.4", matcher.group(6));
10272       assertEquals("access", matcher.group(7));
10273       assertEquals("update", matcher.group(8));
10274 
10275       subjects = grouperSession.getAccessResolver().getSubjectsWithPrivilege(replaceGroup, AccessPrivilege.UPDATE);
10276 
10277       assertEquals(1, GrouperUtil.length(subjects));
10278       assertEquals(SubjectTestHelper.SUBJ4_ID, subjects.iterator().next().getId());
10279     } finally {
10280       System.setOut(systemOut);
10281     }
10282 
10283   }
10284 
10285   /**
10286    * @throws Exception
10287    */
10288   public void testGetAttributeAssignsGroup() throws Exception {
10289 
10290     AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
10291     AttributeDefName attributeDefName2 = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignAssignName");
10292 
10293     final AttributeDef attributeDef = attributeDefName.getAttributeDef();
10294 
10295     final AttributeDef attributeDef2 = attributeDefName2.getAttributeDef();
10296 
10297     attributeDef2.setAssignToGroup(false);
10298     attributeDef2.setAssignToGroupAssn(true);
10299     attributeDef2.store();
10300 
10301     Group group = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
10302       .assignGroupNameToEdit("test:groupTestAttrAssign").assignName("test:groupTestAttrAssign").assignCreateParentStemsIfNotExist(true)
10303       .assignDescription("description").save();
10304 
10305     //test subject 0 can view and read
10306     group.grantPriv(SubjectTestHelper.SUBJ0, AccessPrivilege.VIEW);
10307     attributeDef.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ0, AttributeDefPrivilege.ATTR_READ, false);
10308 
10309     //test subject 0 can read the assignment on assignment
10310     attributeDef2.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ0, AttributeDefPrivilege.ATTR_READ, false);
10311 
10312     AttributeAssignResult attributeAssignResult = group.getAttributeDelegate().assignAttribute(attributeDefName);
10313     AttributeAssign attributeAssign = attributeAssignResult.getAttributeAssign();
10314 
10315     AttributeAssignResult attributeAssignResult2 = attributeAssign.getAttributeDelegate().assignAttribute(attributeDefName2);
10316     AttributeAssign attributeAssign2 = attributeAssignResult2.getAttributeAssign();
10317 
10318     PrintStream systemOut = System.out;
10319 
10320     ByteArrayOutputStream baos = new ByteArrayOutputStream();
10321     System.setOut(new PrintStream(baos));
10322 
10323     try {
10324 
10325       GrouperClient.main(GrouperClientUtils.splitTrim(
10326           "--operation=getAttributeAssignmentsWs --attributeAssignType=group --attributeDefNames=test:testAttributeAssignDefNameDef",
10327           " "));
10328       System.out.flush();
10329       String output = new String(baos.toByteArray());
10330 
10331       System.setOut(systemOut);
10332 
10333       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
10334 
10335       // match: Index: 0: attributeAssignType: group, owner: test:groupTestAttrAssign, attributeDefNameName test:testAttributeAssignDefName, action: assign, values: 15,5,5, enable: T, id: a9c83eeb78c04ae5befcea36272d318c
10336       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
10337       Pattern pattern = Pattern
10338           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
10339       String outputLine = outputLines[0];
10340 
10341       Matcher matcher = pattern.matcher(outputLines[0]);
10342 
10343       assertTrue(outputLine, matcher.matches());
10344       assertEquals(outputLine, "0", matcher.group(1));
10345       assertEquals(outputLine, "group", matcher.group(2));
10346       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
10347       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
10348       assertEquals(outputLine, "assign", matcher.group(5));
10349       assertEquals(outputLine, "none", matcher.group(6));
10350       assertEquals(outputLine, "T", matcher.group(7));
10351       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
10352 
10353       assertTrue(GrouperClientWs.mostRecentRequest,
10354           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
10355       assertTrue(GrouperClientWs.mostRecentRequest,
10356           !GrouperClientWs.mostRecentRequest.contains("actions"));
10357       assertTrue(GrouperClientWs.mostRecentRequest,
10358           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
10359       assertTrue(GrouperClientWs.mostRecentRequest,
10360           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
10361       assertTrue(GrouperClientWs.mostRecentRequest,
10362           !GrouperClientWs.mostRecentRequest.contains("enabled"));
10363       assertTrue(GrouperClientWs.mostRecentRequest,
10364           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
10365       assertTrue(GrouperClientWs.mostRecentRequest,
10366           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
10367       assertTrue(GrouperClientWs.mostRecentRequest,
10368           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
10369       assertTrue(GrouperClientWs.mostRecentRequest,
10370           !GrouperClientWs.mostRecentRequest.contains("params"));
10371       assertTrue(GrouperClientWs.mostRecentRequest,
10372           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
10373       assertTrue(GrouperClientWs.mostRecentRequest,
10374           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
10375       assertTrue(GrouperClientWs.mostRecentRequest,
10376           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
10377       assertTrue(GrouperClientWs.mostRecentRequest,
10378           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
10379       assertTrue(GrouperClientWs.mostRecentRequest,
10380           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
10381       assertTrue(GrouperClientWs.mostRecentRequest,
10382           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
10383       assertTrue(GrouperClientWs.mostRecentRequest,
10384           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
10385       assertTrue(GrouperClientWs.mostRecentRequest,
10386           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
10387       assertTrue(GrouperClientWs.mostRecentRequest,
10388           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
10389       assertTrue(GrouperClientWs.mostRecentRequest,
10390           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
10391 
10392       // ######################################################
10393       // Try attributeDefId
10394 
10395       baos = new ByteArrayOutputStream();
10396       System.setOut(new PrintStream(baos));
10397 
10398       GrouperClient.main(GrouperClientUtils.splitTrim(
10399           "--operation=getAttributeAssignmentsWs --attributeAssignType=group --attributeDefUuids=" + attributeDef.getId(),
10400           " "));
10401 
10402 
10403       System.out.flush();
10404       output = new String(baos.toByteArray());
10405 
10406       System.setOut(systemOut);
10407 
10408       outputLines = GrouperClientUtils.splitTrim(output, "\n");
10409 
10410       outputLine = outputLines[0];
10411 
10412       matcher = pattern.matcher(outputLines[0]);
10413 
10414       assertTrue(outputLine, matcher.matches());
10415       assertEquals(outputLine, "0", matcher.group(1));
10416       assertEquals(outputLine, "group", matcher.group(2));
10417       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
10418       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
10419       assertEquals(outputLine, "assign", matcher.group(5));
10420       assertEquals(outputLine, "none", matcher.group(6));
10421       assertEquals(outputLine, "T", matcher.group(7));
10422       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
10423 
10424       assertTrue(GrouperClientWs.mostRecentRequest,
10425           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
10426       assertTrue(GrouperClientWs.mostRecentRequest,
10427           !GrouperClientWs.mostRecentRequest.contains("actions"));
10428       assertTrue(GrouperClientWs.mostRecentRequest,
10429           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
10430       assertTrue(GrouperClientWs.mostRecentRequest,
10431           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
10432       assertTrue(GrouperClientWs.mostRecentRequest,
10433           !GrouperClientWs.mostRecentRequest.contains("enabled"));
10434       assertTrue(GrouperClientWs.mostRecentRequest,
10435           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
10436       assertTrue(GrouperClientWs.mostRecentRequest,
10437           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
10438       assertTrue(GrouperClientWs.mostRecentRequest,
10439           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
10440       assertTrue(GrouperClientWs.mostRecentRequest,
10441           !GrouperClientWs.mostRecentRequest.contains("params"));
10442       assertTrue(GrouperClientWs.mostRecentRequest,
10443           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
10444       assertTrue(GrouperClientWs.mostRecentRequest,
10445           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
10446       assertTrue(GrouperClientWs.mostRecentRequest,
10447           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
10448       assertTrue(GrouperClientWs.mostRecentRequest,
10449           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
10450       assertTrue(GrouperClientWs.mostRecentRequest,
10451           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
10452       assertTrue(GrouperClientWs.mostRecentRequest,
10453           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
10454       assertTrue(GrouperClientWs.mostRecentRequest,
10455           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
10456       assertTrue(GrouperClientWs.mostRecentRequest,
10457           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
10458       assertTrue(GrouperClientWs.mostRecentRequest,
10459           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
10460       assertTrue(GrouperClientWs.mostRecentRequest,
10461           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
10462 
10463 
10464       // ######################################################
10465       // Try attributeDefIdIndex
10466 
10467       baos = new ByteArrayOutputStream();
10468       System.setOut(new PrintStream(baos));
10469 
10470       GrouperClient.main(GrouperClientUtils.splitTrim(
10471           "--operation=getAttributeAssignmentsWs --attributeAssignType=group --attributeDefIdIndexes=" + attributeDef.getIdIndex(),
10472           " "));
10473 
10474 
10475       System.out.flush();
10476       output = new String(baos.toByteArray());
10477 
10478       System.setOut(systemOut);
10479 
10480       outputLines = GrouperClientUtils.splitTrim(output, "\n");
10481 
10482       outputLine = outputLines[0];
10483 
10484       matcher = pattern.matcher(outputLines[0]);
10485 
10486       assertTrue(outputLine, matcher.matches());
10487       assertEquals(outputLine, "0", matcher.group(1));
10488       assertEquals(outputLine, "group", matcher.group(2));
10489       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
10490       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
10491       assertEquals(outputLine, "assign", matcher.group(5));
10492       assertEquals(outputLine, "none", matcher.group(6));
10493       assertEquals(outputLine, "T", matcher.group(7));
10494       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
10495 
10496       assertTrue(GrouperClientWs.mostRecentRequest,
10497           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
10498       assertTrue(GrouperClientWs.mostRecentRequest,
10499           !GrouperClientWs.mostRecentRequest.contains("actions"));
10500       assertTrue(GrouperClientWs.mostRecentRequest,
10501           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
10502       assertTrue(GrouperClientWs.mostRecentRequest,
10503           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
10504       assertTrue(GrouperClientWs.mostRecentRequest,
10505           !GrouperClientWs.mostRecentRequest.contains("enabled"));
10506       assertTrue(GrouperClientWs.mostRecentRequest,
10507           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
10508       assertTrue(GrouperClientWs.mostRecentRequest,
10509           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
10510       assertTrue(GrouperClientWs.mostRecentRequest,
10511           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
10512       assertTrue(GrouperClientWs.mostRecentRequest,
10513           !GrouperClientWs.mostRecentRequest.contains("params"));
10514       assertTrue(GrouperClientWs.mostRecentRequest,
10515           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
10516       assertTrue(GrouperClientWs.mostRecentRequest,
10517           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
10518       assertTrue(GrouperClientWs.mostRecentRequest,
10519           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<idIndex>"));
10520       assertTrue(GrouperClientWs.mostRecentRequest,
10521           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
10522       assertTrue(GrouperClientWs.mostRecentRequest,
10523           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
10524       assertTrue(GrouperClientWs.mostRecentRequest,
10525           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
10526       assertTrue(GrouperClientWs.mostRecentRequest,
10527           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
10528       assertTrue(GrouperClientWs.mostRecentRequest,
10529           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
10530       assertTrue(GrouperClientWs.mostRecentRequest,
10531           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
10532       assertTrue(GrouperClientWs.mostRecentRequest,
10533           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
10534 
10535 
10536       // ######################################################
10537       // Try attributeDefNameName
10538 
10539       baos = new ByteArrayOutputStream();
10540       System.setOut(new PrintStream(baos));
10541 
10542       GrouperClient.main(GrouperClientUtils.splitTrim(
10543           "--operation=getAttributeAssignmentsWs --attributeAssignType=group --attributeDefNameNames=" + attributeDefName.getName(),
10544           " "));
10545 
10546 
10547       System.out.flush();
10548       output = new String(baos.toByteArray());
10549 
10550       System.setOut(systemOut);
10551 
10552       outputLines = GrouperClientUtils.splitTrim(output, "\n");
10553 
10554       outputLine = outputLines[0];
10555 
10556       matcher = pattern.matcher(outputLines[0]);
10557 
10558       assertTrue(outputLine, matcher.matches());
10559       assertEquals(outputLine, "0", matcher.group(1));
10560       assertEquals(outputLine, "group", matcher.group(2));
10561       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
10562       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
10563       assertEquals(outputLine, "assign", matcher.group(5));
10564       assertEquals(outputLine, "none", matcher.group(6));
10565       assertEquals(outputLine, "T", matcher.group(7));
10566       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
10567 
10568       assertTrue(GrouperClientWs.mostRecentRequest,
10569           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
10570       assertTrue(GrouperClientWs.mostRecentRequest,
10571           !GrouperClientWs.mostRecentRequest.contains("actions"));
10572       assertTrue(GrouperClientWs.mostRecentRequest,
10573           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
10574       assertTrue(GrouperClientWs.mostRecentRequest,
10575           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
10576       assertTrue(GrouperClientWs.mostRecentRequest,
10577           !GrouperClientWs.mostRecentRequest.contains("enabled"));
10578       assertTrue(GrouperClientWs.mostRecentRequest,
10579           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
10580       assertTrue(GrouperClientWs.mostRecentRequest,
10581           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
10582       assertTrue(GrouperClientWs.mostRecentRequest,
10583           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
10584       assertTrue(GrouperClientWs.mostRecentRequest,
10585           !GrouperClientWs.mostRecentRequest.contains("params"));
10586       assertTrue(GrouperClientWs.mostRecentRequest,
10587           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
10588       assertTrue(GrouperClientWs.mostRecentRequest,
10589           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
10590       assertTrue(GrouperClientWs.mostRecentRequest,
10591           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
10592       assertTrue(GrouperClientWs.mostRecentRequest,
10593           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
10594       assertTrue(GrouperClientWs.mostRecentRequest,
10595           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
10596       assertTrue(GrouperClientWs.mostRecentRequest,
10597           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
10598       assertTrue(GrouperClientWs.mostRecentRequest,
10599           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
10600       assertTrue(GrouperClientWs.mostRecentRequest,
10601           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
10602       assertTrue(GrouperClientWs.mostRecentRequest,
10603           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
10604       assertTrue(GrouperClientWs.mostRecentRequest,
10605           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
10606 
10607 
10608 
10609       // ######################################################
10610       // Try attributeDefNameUuid
10611 
10612       baos = new ByteArrayOutputStream();
10613       System.setOut(new PrintStream(baos));
10614 
10615       GrouperClient.main(GrouperClientUtils.splitTrim(
10616           "--operation=getAttributeAssignmentsWs --attributeAssignType=group --attributeDefNameUuids=" + attributeDefName.getId(),
10617           " "));
10618 
10619 
10620       System.out.flush();
10621       output = new String(baos.toByteArray());
10622 
10623       System.setOut(systemOut);
10624 
10625       outputLines = GrouperClientUtils.splitTrim(output, "\n");
10626 
10627       outputLine = outputLines[0];
10628 
10629       matcher = pattern.matcher(outputLines[0]);
10630 
10631       assertTrue(outputLine, matcher.matches());
10632       assertEquals(outputLine, "0", matcher.group(1));
10633       assertEquals(outputLine, "group", matcher.group(2));
10634       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
10635       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
10636       assertEquals(outputLine, "assign", matcher.group(5));
10637       assertEquals(outputLine, "none", matcher.group(6));
10638       assertEquals(outputLine, "T", matcher.group(7));
10639       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
10640 
10641       assertTrue(GrouperClientWs.mostRecentRequest,
10642           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
10643       assertTrue(GrouperClientWs.mostRecentRequest,
10644           !GrouperClientWs.mostRecentRequest.contains("actions"));
10645       assertTrue(GrouperClientWs.mostRecentRequest,
10646           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
10647       assertTrue(GrouperClientWs.mostRecentRequest,
10648           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
10649       assertTrue(GrouperClientWs.mostRecentRequest,
10650           !GrouperClientWs.mostRecentRequest.contains("enabled"));
10651       assertTrue(GrouperClientWs.mostRecentRequest,
10652           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
10653       assertTrue(GrouperClientWs.mostRecentRequest,
10654           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
10655       assertTrue(GrouperClientWs.mostRecentRequest,
10656           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
10657       assertTrue(GrouperClientWs.mostRecentRequest,
10658           !GrouperClientWs.mostRecentRequest.contains("params"));
10659       assertTrue(GrouperClientWs.mostRecentRequest,
10660           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
10661       assertTrue(GrouperClientWs.mostRecentRequest,
10662           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
10663       assertTrue(GrouperClientWs.mostRecentRequest,
10664           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
10665       assertTrue(GrouperClientWs.mostRecentRequest,
10666           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
10667       assertTrue(GrouperClientWs.mostRecentRequest,
10668           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
10669       assertTrue(GrouperClientWs.mostRecentRequest,
10670           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
10671       assertTrue(GrouperClientWs.mostRecentRequest,
10672           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
10673       assertTrue(GrouperClientWs.mostRecentRequest,
10674           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
10675       assertTrue(GrouperClientWs.mostRecentRequest,
10676           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
10677       assertTrue(GrouperClientWs.mostRecentRequest,
10678           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
10679 
10680       // ######################################################
10681       // Try attributeDefNameIdIndex
10682 
10683       baos = new ByteArrayOutputStream();
10684       System.setOut(new PrintStream(baos));
10685 
10686       GrouperClient.main(GrouperClientUtils.splitTrim(
10687           "--operation=getAttributeAssignmentsWs --attributeAssignType=group --attributeDefNameIdIndexes=" + attributeDefName.getIdIndex(),
10688           " "));
10689 
10690 
10691       System.out.flush();
10692       output = new String(baos.toByteArray());
10693 
10694       System.setOut(systemOut);
10695 
10696       outputLines = GrouperClientUtils.splitTrim(output, "\n");
10697 
10698       outputLine = outputLines[0];
10699 
10700       matcher = pattern.matcher(outputLines[0]);
10701 
10702       assertTrue(outputLine, matcher.matches());
10703       assertEquals(outputLine, "0", matcher.group(1));
10704       assertEquals(outputLine, "group", matcher.group(2));
10705       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
10706       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
10707       assertEquals(outputLine, "assign", matcher.group(5));
10708       assertEquals(outputLine, "none", matcher.group(6));
10709       assertEquals(outputLine, "T", matcher.group(7));
10710       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
10711 
10712       assertTrue(GrouperClientWs.mostRecentRequest,
10713           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
10714       assertTrue(GrouperClientWs.mostRecentRequest,
10715           !GrouperClientWs.mostRecentRequest.contains("actions"));
10716       assertTrue(GrouperClientWs.mostRecentRequest,
10717           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
10718       assertTrue(GrouperClientWs.mostRecentRequest,
10719           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
10720       assertTrue(GrouperClientWs.mostRecentRequest,
10721           !GrouperClientWs.mostRecentRequest.contains("enabled"));
10722       assertTrue(GrouperClientWs.mostRecentRequest,
10723           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
10724       assertTrue(GrouperClientWs.mostRecentRequest,
10725           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
10726       assertTrue(GrouperClientWs.mostRecentRequest,
10727           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
10728       assertTrue(GrouperClientWs.mostRecentRequest,
10729           !GrouperClientWs.mostRecentRequest.contains("params"));
10730       assertTrue(GrouperClientWs.mostRecentRequest,
10731           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
10732       assertTrue(GrouperClientWs.mostRecentRequest,
10733           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
10734       assertTrue(GrouperClientWs.mostRecentRequest,
10735           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
10736       assertTrue(GrouperClientWs.mostRecentRequest,
10737           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups") && GrouperClientWs.mostRecentRequest.contains("<idIndex>"));
10738       assertTrue(GrouperClientWs.mostRecentRequest,
10739           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
10740       assertTrue(GrouperClientWs.mostRecentRequest,
10741           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
10742       assertTrue(GrouperClientWs.mostRecentRequest,
10743           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
10744       assertTrue(GrouperClientWs.mostRecentRequest,
10745           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
10746       assertTrue(GrouperClientWs.mostRecentRequest,
10747           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
10748       assertTrue(GrouperClientWs.mostRecentRequest,
10749           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
10750 
10751 
10752       // ######################################################
10753       // Try ownerGroupNames
10754 
10755       baos = new ByteArrayOutputStream();
10756       System.setOut(new PrintStream(baos));
10757 
10758       GrouperClient.main(GrouperClientUtils.splitTrim(
10759           "--operation=getAttributeAssignmentsWs --attributeAssignType=group --ownerGroupNames=" + group.getName(),
10760           " "));
10761 
10762 
10763       System.out.flush();
10764       output = new String(baos.toByteArray());
10765 
10766       System.setOut(systemOut);
10767 
10768       outputLines = GrouperClientUtils.splitTrim(output, "\n");
10769 
10770       outputLine = outputLines[0];
10771 
10772       matcher = pattern.matcher(outputLines[0]);
10773 
10774       assertTrue(outputLine, matcher.matches());
10775       assertEquals(outputLine, "0", matcher.group(1));
10776       assertEquals(outputLine, "group", matcher.group(2));
10777       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
10778       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
10779       assertEquals(outputLine, "assign", matcher.group(5));
10780       assertEquals(outputLine, "none", matcher.group(6));
10781       assertEquals(outputLine, "T", matcher.group(7));
10782       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
10783 
10784       assertTrue(GrouperClientWs.mostRecentRequest,
10785           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
10786       assertTrue(GrouperClientWs.mostRecentRequest,
10787           !GrouperClientWs.mostRecentRequest.contains("actions"));
10788       assertTrue(GrouperClientWs.mostRecentRequest,
10789           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
10790       assertTrue(GrouperClientWs.mostRecentRequest,
10791           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
10792       assertTrue(GrouperClientWs.mostRecentRequest,
10793           !GrouperClientWs.mostRecentRequest.contains("enabled"));
10794       assertTrue(GrouperClientWs.mostRecentRequest,
10795           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
10796       assertTrue(GrouperClientWs.mostRecentRequest,
10797           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
10798       assertTrue(GrouperClientWs.mostRecentRequest,
10799           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
10800       assertTrue(GrouperClientWs.mostRecentRequest,
10801           !GrouperClientWs.mostRecentRequest.contains("params"));
10802       assertTrue(GrouperClientWs.mostRecentRequest,
10803           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
10804       assertTrue(GrouperClientWs.mostRecentRequest,
10805           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
10806       assertTrue(GrouperClientWs.mostRecentRequest,
10807           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
10808       assertTrue(GrouperClientWs.mostRecentRequest,
10809           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
10810       assertTrue(GrouperClientWs.mostRecentRequest,
10811           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
10812       assertTrue(GrouperClientWs.mostRecentRequest,
10813           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
10814       assertTrue(GrouperClientWs.mostRecentRequest,
10815           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
10816       assertTrue(GrouperClientWs.mostRecentRequest,
10817           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
10818       assertTrue(GrouperClientWs.mostRecentRequest,
10819           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
10820       assertTrue(GrouperClientWs.mostRecentRequest,
10821           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
10822 
10823 
10824 
10825 
10826       // ######################################################
10827       // Try ownerGroupUuids
10828 
10829       baos = new ByteArrayOutputStream();
10830       System.setOut(new PrintStream(baos));
10831 
10832       GrouperClient.main(GrouperClientUtils.splitTrim(
10833           "--operation=getAttributeAssignmentsWs --attributeAssignType=group --ownerGroupUuids=" + group.getId(),
10834           " "));
10835 
10836 
10837       System.out.flush();
10838       output = new String(baos.toByteArray());
10839 
10840       System.setOut(systemOut);
10841 
10842       outputLines = GrouperClientUtils.splitTrim(output, "\n");
10843 
10844       outputLine = outputLines[0];
10845 
10846       matcher = pattern.matcher(outputLines[0]);
10847 
10848       assertTrue(outputLine, matcher.matches());
10849       assertEquals(outputLine, "0", matcher.group(1));
10850       assertEquals(outputLine, "group", matcher.group(2));
10851       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
10852       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
10853       assertEquals(outputLine, "assign", matcher.group(5));
10854       assertEquals(outputLine, "none", matcher.group(6));
10855       assertEquals(outputLine, "T", matcher.group(7));
10856       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
10857 
10858       assertTrue(GrouperClientWs.mostRecentRequest,
10859           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
10860       assertTrue(GrouperClientWs.mostRecentRequest,
10861           !GrouperClientWs.mostRecentRequest.contains("actions"));
10862       assertTrue(GrouperClientWs.mostRecentRequest,
10863           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
10864       assertTrue(GrouperClientWs.mostRecentRequest,
10865           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
10866       assertTrue(GrouperClientWs.mostRecentRequest,
10867           !GrouperClientWs.mostRecentRequest.contains("enabled"));
10868       assertTrue(GrouperClientWs.mostRecentRequest,
10869           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
10870       assertTrue(GrouperClientWs.mostRecentRequest,
10871           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
10872       assertTrue(GrouperClientWs.mostRecentRequest,
10873           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
10874       assertTrue(GrouperClientWs.mostRecentRequest,
10875           !GrouperClientWs.mostRecentRequest.contains("params"));
10876       assertTrue(GrouperClientWs.mostRecentRequest,
10877           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
10878       assertTrue(GrouperClientWs.mostRecentRequest,
10879           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
10880       assertTrue(GrouperClientWs.mostRecentRequest,
10881           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
10882       assertTrue(GrouperClientWs.mostRecentRequest,
10883           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
10884       assertTrue(GrouperClientWs.mostRecentRequest,
10885           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
10886       assertTrue(GrouperClientWs.mostRecentRequest,
10887           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
10888       assertTrue(GrouperClientWs.mostRecentRequest,
10889           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
10890       assertTrue(GrouperClientWs.mostRecentRequest,
10891           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
10892       assertTrue(GrouperClientWs.mostRecentRequest,
10893           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
10894       assertTrue(GrouperClientWs.mostRecentRequest,
10895           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
10896 
10897 
10898       // ######################################################
10899       // Try ownerGroupUuids
10900 
10901       baos = new ByteArrayOutputStream();
10902       System.setOut(new PrintStream(baos));
10903 
10904       GrouperClient.main(GrouperClientUtils.splitTrim(
10905           "--operation=getAttributeAssignmentsWs --attributeAssignType=group --ownerGroupIdIndexes=" + group.getIdIndex(),
10906           " "));
10907 
10908 
10909       System.out.flush();
10910       output = new String(baos.toByteArray());
10911 
10912       System.setOut(systemOut);
10913 
10914       outputLines = GrouperClientUtils.splitTrim(output, "\n");
10915 
10916       outputLine = outputLines[0];
10917 
10918       matcher = pattern.matcher(outputLines[0]);
10919 
10920       assertTrue(outputLine, matcher.matches());
10921       assertEquals(outputLine, "0", matcher.group(1));
10922       assertEquals(outputLine, "group", matcher.group(2));
10923       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
10924       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
10925       assertEquals(outputLine, "assign", matcher.group(5));
10926       assertEquals(outputLine, "none", matcher.group(6));
10927       assertEquals(outputLine, "T", matcher.group(7));
10928       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
10929 
10930       assertTrue(GrouperClientWs.mostRecentRequest,
10931           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
10932       assertTrue(GrouperClientWs.mostRecentRequest,
10933           !GrouperClientWs.mostRecentRequest.contains("actions"));
10934       assertTrue(GrouperClientWs.mostRecentRequest,
10935           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
10936       assertTrue(GrouperClientWs.mostRecentRequest,
10937           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
10938       assertTrue(GrouperClientWs.mostRecentRequest,
10939           !GrouperClientWs.mostRecentRequest.contains("enabled"));
10940       assertTrue(GrouperClientWs.mostRecentRequest,
10941           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
10942       assertTrue(GrouperClientWs.mostRecentRequest,
10943           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
10944       assertTrue(GrouperClientWs.mostRecentRequest,
10945           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
10946       assertTrue(GrouperClientWs.mostRecentRequest,
10947           !GrouperClientWs.mostRecentRequest.contains("params"));
10948       assertTrue(GrouperClientWs.mostRecentRequest,
10949           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
10950       assertTrue(GrouperClientWs.mostRecentRequest,
10951           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
10952       assertTrue(GrouperClientWs.mostRecentRequest,
10953           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
10954       assertTrue(GrouperClientWs.mostRecentRequest,
10955           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
10956       assertTrue(GrouperClientWs.mostRecentRequest,
10957           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
10958       assertTrue(GrouperClientWs.mostRecentRequest,
10959           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
10960       assertTrue(GrouperClientWs.mostRecentRequest,
10961           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
10962       assertTrue(GrouperClientWs.mostRecentRequest,
10963           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
10964       assertTrue(GrouperClientWs.mostRecentRequest,
10965           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
10966       assertTrue(GrouperClientWs.mostRecentRequest,
10967           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
10968 
10969 
10970 
10971       // ######################################################
10972       // Try enabled
10973 
10974       baos = new ByteArrayOutputStream();
10975       System.setOut(new PrintStream(baos));
10976 
10977       GrouperClient.main(GrouperClientUtils.splitTrim(
10978           "--operation=getAttributeAssignmentsWs --attributeAssignType=group --ownerGroupUuids=" + group.getId()
10979           + " --enabled=F",
10980           " "));
10981 
10982 
10983       System.out.flush();
10984       output = new String(baos.toByteArray());
10985 
10986       System.setOut(systemOut);
10987 
10988       outputLines = GrouperClientUtils.splitTrim(output, "\n");
10989 
10990       assertTrue(outputLines == null || outputLines.length == 0 || StringUtils.isBlank(outputLines[0]));
10991 
10992       assertTrue(GrouperClientWs.mostRecentRequest,
10993           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
10994       assertTrue(GrouperClientWs.mostRecentRequest,
10995           !GrouperClientWs.mostRecentRequest.contains("actions"));
10996       assertTrue(GrouperClientWs.mostRecentRequest,
10997           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
10998       assertTrue(GrouperClientWs.mostRecentRequest,
10999           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
11000       assertTrue(GrouperClientWs.mostRecentRequest,
11001           GrouperClientWs.mostRecentRequest.contains("enabled"));
11002       assertTrue(GrouperClientWs.mostRecentRequest,
11003           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
11004       assertTrue(GrouperClientWs.mostRecentRequest,
11005           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
11006       assertTrue(GrouperClientWs.mostRecentRequest,
11007           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
11008       assertTrue(GrouperClientWs.mostRecentRequest,
11009           !GrouperClientWs.mostRecentRequest.contains("params"));
11010       assertTrue(GrouperClientWs.mostRecentRequest,
11011           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
11012       assertTrue(GrouperClientWs.mostRecentRequest,
11013           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
11014       assertTrue(GrouperClientWs.mostRecentRequest,
11015           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
11016       assertTrue(GrouperClientWs.mostRecentRequest,
11017           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
11018       assertTrue(GrouperClientWs.mostRecentRequest,
11019           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
11020       assertTrue(GrouperClientWs.mostRecentRequest,
11021           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
11022       assertTrue(GrouperClientWs.mostRecentRequest,
11023           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
11024       assertTrue(GrouperClientWs.mostRecentRequest,
11025           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
11026       assertTrue(GrouperClientWs.mostRecentRequest,
11027           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
11028       assertTrue(GrouperClientWs.mostRecentRequest,
11029           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
11030 
11031 
11032       // ######################################################
11033       // Try actions
11034 
11035       baos = new ByteArrayOutputStream();
11036       System.setOut(new PrintStream(baos));
11037 
11038       GrouperClient.main(GrouperClientUtils.splitTrim(
11039           "--operation=getAttributeAssignmentsWs --attributeAssignType=group --ownerGroupUuids=" + group.getId()
11040           + " --actions=a",
11041           " "));
11042 
11043 
11044       System.out.flush();
11045       output = new String(baos.toByteArray());
11046 
11047       System.setOut(systemOut);
11048 
11049       outputLines = GrouperClientUtils.splitTrim(output, "\n");
11050 
11051       assertTrue(outputLines == null || outputLines.length == 0 || StringUtils.isBlank(outputLines[0]));
11052 
11053       assertTrue(GrouperClientWs.mostRecentRequest,
11054           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
11055       assertTrue(GrouperClientWs.mostRecentRequest,
11056           GrouperClientWs.mostRecentRequest.contains("actions"));
11057       assertTrue(GrouperClientWs.mostRecentRequest,
11058           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
11059       assertTrue(GrouperClientWs.mostRecentRequest,
11060           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
11061       assertTrue(GrouperClientWs.mostRecentRequest,
11062           !GrouperClientWs.mostRecentRequest.contains("enabled"));
11063       assertTrue(GrouperClientWs.mostRecentRequest,
11064           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
11065       assertTrue(GrouperClientWs.mostRecentRequest,
11066           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
11067       assertTrue(GrouperClientWs.mostRecentRequest,
11068           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
11069       assertTrue(GrouperClientWs.mostRecentRequest,
11070           !GrouperClientWs.mostRecentRequest.contains("params"));
11071       assertTrue(GrouperClientWs.mostRecentRequest,
11072           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
11073       assertTrue(GrouperClientWs.mostRecentRequest,
11074           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
11075       assertTrue(GrouperClientWs.mostRecentRequest,
11076           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
11077       assertTrue(GrouperClientWs.mostRecentRequest,
11078           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
11079       assertTrue(GrouperClientWs.mostRecentRequest,
11080           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
11081       assertTrue(GrouperClientWs.mostRecentRequest,
11082           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
11083       assertTrue(GrouperClientWs.mostRecentRequest,
11084           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
11085       assertTrue(GrouperClientWs.mostRecentRequest,
11086           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
11087       assertTrue(GrouperClientWs.mostRecentRequest,
11088           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
11089       assertTrue(GrouperClientWs.mostRecentRequest,
11090           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
11091 
11092 
11093       // ######################################################
11094       // Try includeAssignmentsOnAssignments
11095 
11096       baos = new ByteArrayOutputStream();
11097       System.setOut(new PrintStream(baos));
11098 
11099       GrouperClient.main(GrouperClientUtils.splitTrim(
11100           "--operation=getAttributeAssignmentsWs --attributeAssignType=group --ownerGroupUuids=" + group.getId()
11101           + " --includeAssignmentsOnAssignments=T",
11102           " "));
11103 
11104 
11105       System.out.flush();
11106       output = new String(baos.toByteArray());
11107 
11108       System.setOut(systemOut);
11109 
11110       outputLines = GrouperClientUtils.splitTrim(output, "\n");
11111 
11112 //      assertTrue(outputLines == null || outputLines.length == 0 || StringUtils.isBlank(outputLines[0]));
11113 
11114       outputLine = outputLines[0];
11115 
11116       matcher = pattern.matcher(outputLine);
11117 
11118       assertTrue(outputLine, matcher.matches());
11119       assertEquals(outputLine, "0", matcher.group(1));
11120       assertEquals(outputLine, "group", matcher.group(2));
11121       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
11122       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
11123       assertEquals(outputLine, "assign", matcher.group(5));
11124       assertEquals(outputLine, "none", matcher.group(6));
11125       assertEquals(outputLine, "T", matcher.group(7));
11126       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
11127 
11128       outputLine = outputLines[1];
11129 
11130       matcher = pattern.matcher(outputLine);
11131 
11132       //Index: 1: attributeAssignType: group_asgn, owner: e11b0b9174ec474184e878ac3e5e27e3, attributeDefNameName: test:testAttributeAssignAssignName,
11133       //action: assign, values: none, enabled: T, id: e11b0b9174ec474184e878ac3e5e27e3 expected:<test:groupTestAttrAssign> but was:<e11b0b9174ec474184e878ac3e5e27e3>
11134 
11135       assertTrue(outputLine, matcher.matches());
11136       assertEquals(outputLine, "1", matcher.group(1));
11137       assertEquals(outputLine, "group_asgn", matcher.group(2));
11138       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
11139       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
11140       assertEquals(outputLine, "assign", matcher.group(5));
11141       assertEquals(outputLine, "none", matcher.group(6));
11142       assertEquals(outputLine, "T", matcher.group(7));
11143       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
11144 
11145       assertTrue(GrouperClientWs.mostRecentRequest,
11146           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
11147       assertTrue(GrouperClientWs.mostRecentRequest,
11148           !GrouperClientWs.mostRecentRequest.contains("actions"));
11149       assertTrue(GrouperClientWs.mostRecentRequest,
11150           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
11151       assertTrue(GrouperClientWs.mostRecentRequest,
11152           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
11153       assertTrue(GrouperClientWs.mostRecentRequest,
11154           !GrouperClientWs.mostRecentRequest.contains("enabled"));
11155       assertTrue(GrouperClientWs.mostRecentRequest,
11156           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
11157       assertTrue(GrouperClientWs.mostRecentRequest,
11158           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
11159       assertTrue(GrouperClientWs.mostRecentRequest,
11160           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
11161       assertTrue(GrouperClientWs.mostRecentRequest,
11162           !GrouperClientWs.mostRecentRequest.contains("params"));
11163       assertTrue(GrouperClientWs.mostRecentRequest,
11164           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
11165       assertTrue(GrouperClientWs.mostRecentRequest,
11166           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
11167       assertTrue(GrouperClientWs.mostRecentRequest,
11168           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
11169       assertTrue(GrouperClientWs.mostRecentRequest,
11170           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
11171       assertTrue(GrouperClientWs.mostRecentRequest,
11172           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
11173       assertTrue(GrouperClientWs.mostRecentRequest,
11174           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
11175       assertTrue(GrouperClientWs.mostRecentRequest,
11176           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
11177       assertTrue(GrouperClientWs.mostRecentRequest,
11178           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
11179       assertTrue(GrouperClientWs.mostRecentRequest,
11180           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
11181       assertTrue(GrouperClientWs.mostRecentRequest,
11182           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
11183 
11184 
11185 
11186 
11187       // ######################################################
11188       // Try includeGroupDetail
11189 
11190       baos = new ByteArrayOutputStream();
11191       System.setOut(new PrintStream(baos));
11192 
11193       GrouperClient.main(GrouperClientUtils.splitTrim(
11194           "--operation=getAttributeAssignmentsWs --attributeAssignType=group --ownerGroupUuids=" + group.getId()
11195           + " --includeGroupDetail=T",
11196           " "));
11197 
11198 
11199       System.out.flush();
11200       output = new String(baos.toByteArray());
11201 
11202       System.setOut(systemOut);
11203 
11204       outputLines = GrouperClientUtils.splitTrim(output, "\n");
11205 
11206       outputLine = outputLines[0];
11207 
11208       matcher = pattern.matcher(outputLines[0]);
11209 
11210       assertTrue(outputLine, matcher.matches());
11211       assertEquals(outputLine, "0", matcher.group(1));
11212       assertEquals(outputLine, "group", matcher.group(2));
11213       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
11214       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
11215       assertEquals(outputLine, "assign", matcher.group(5));
11216       assertEquals(outputLine, "none", matcher.group(6));
11217       assertEquals(outputLine, "T", matcher.group(7));
11218       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
11219 
11220       assertTrue(GrouperClientWs.mostRecentRequest,
11221           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
11222       assertTrue(GrouperClientWs.mostRecentRequest,
11223           !GrouperClientWs.mostRecentRequest.contains("actions"));
11224       assertTrue(GrouperClientWs.mostRecentRequest,
11225           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
11226       assertTrue(GrouperClientWs.mostRecentRequest,
11227           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
11228       assertTrue(GrouperClientWs.mostRecentRequest,
11229           !GrouperClientWs.mostRecentRequest.contains("enabled"));
11230       assertTrue(GrouperClientWs.mostRecentRequest,
11231           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
11232       assertTrue(GrouperClientWs.mostRecentRequest,
11233           GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
11234       assertTrue(GrouperClientWs.mostRecentRequest,
11235           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
11236       assertTrue(GrouperClientWs.mostRecentRequest,
11237           !GrouperClientWs.mostRecentRequest.contains("params"));
11238       assertTrue(GrouperClientWs.mostRecentRequest,
11239           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
11240       assertTrue(GrouperClientWs.mostRecentRequest,
11241           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
11242       assertTrue(GrouperClientWs.mostRecentRequest,
11243           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
11244       assertTrue(GrouperClientWs.mostRecentRequest,
11245           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
11246       assertTrue(GrouperClientWs.mostRecentRequest,
11247           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
11248       assertTrue(GrouperClientWs.mostRecentRequest,
11249           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
11250       assertTrue(GrouperClientWs.mostRecentRequest,
11251           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
11252       assertTrue(GrouperClientWs.mostRecentRequest,
11253           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
11254       assertTrue(GrouperClientWs.mostRecentRequest,
11255           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
11256       assertTrue(GrouperClientWs.mostRecentRequest,
11257           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
11258       assertTrue(GrouperClientWs.mostRecentResponse,
11259           GrouperClientWs.mostRecentResponse.contains("hasComposite"));
11260 
11261 
11262 
11263 
11264       // ######################################################
11265       // Try includeSubjectDetail
11266 
11267       baos = new ByteArrayOutputStream();
11268       System.setOut(new PrintStream(baos));
11269 
11270       GrouperClient.main(GrouperClientUtils.splitTrim(
11271           "--operation=getAttributeAssignmentsWs --attributeAssignType=group --ownerGroupUuids=" + group.getId()
11272           + " --includeSubjectDetail=T",
11273           " "));
11274 
11275 
11276       System.out.flush();
11277       output = new String(baos.toByteArray());
11278 
11279       System.setOut(systemOut);
11280 
11281       outputLines = GrouperClientUtils.splitTrim(output, "\n");
11282 
11283       outputLine = outputLines[0];
11284 
11285       matcher = pattern.matcher(outputLines[0]);
11286 
11287       assertTrue(outputLine, matcher.matches());
11288       assertEquals(outputLine, "0", matcher.group(1));
11289       assertEquals(outputLine, "group", matcher.group(2));
11290       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
11291       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
11292       assertEquals(outputLine, "assign", matcher.group(5));
11293       assertEquals(outputLine, "none", matcher.group(6));
11294       assertEquals(outputLine, "T", matcher.group(7));
11295       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
11296 
11297       assertTrue(GrouperClientWs.mostRecentRequest,
11298           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
11299       assertTrue(GrouperClientWs.mostRecentRequest,
11300           !GrouperClientWs.mostRecentRequest.contains("actions"));
11301       assertTrue(GrouperClientWs.mostRecentRequest,
11302           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
11303       assertTrue(GrouperClientWs.mostRecentRequest,
11304           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
11305       assertTrue(GrouperClientWs.mostRecentRequest,
11306           !GrouperClientWs.mostRecentRequest.contains("enabled"));
11307       assertTrue(GrouperClientWs.mostRecentRequest,
11308           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
11309       assertTrue(GrouperClientWs.mostRecentRequest,
11310           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
11311       assertTrue(GrouperClientWs.mostRecentRequest,
11312           GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
11313       assertTrue(GrouperClientWs.mostRecentRequest,
11314           !GrouperClientWs.mostRecentRequest.contains("params"));
11315       assertTrue(GrouperClientWs.mostRecentRequest,
11316           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
11317       assertTrue(GrouperClientWs.mostRecentRequest,
11318           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
11319       assertTrue(GrouperClientWs.mostRecentRequest,
11320           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
11321       assertTrue(GrouperClientWs.mostRecentRequest,
11322           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
11323       assertTrue(GrouperClientWs.mostRecentRequest,
11324           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
11325       assertTrue(GrouperClientWs.mostRecentRequest,
11326           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
11327       assertTrue(GrouperClientWs.mostRecentRequest,
11328           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
11329       assertTrue(GrouperClientWs.mostRecentRequest,
11330           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
11331       assertTrue(GrouperClientWs.mostRecentRequest,
11332           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
11333       assertTrue(GrouperClientWs.mostRecentRequest,
11334           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
11335 
11336 
11337 
11338 
11339 
11340       // ######################################################
11341       // Try subjectAttributeNames
11342 
11343       baos = new ByteArrayOutputStream();
11344       System.setOut(new PrintStream(baos));
11345 
11346       GrouperClient.main(GrouperClientUtils.splitTrim(
11347           "--operation=getAttributeAssignmentsWs --attributeAssignType=group --ownerGroupUuids=" + group.getId()
11348           + " --subjectAttributeNames=abc",
11349           " "));
11350 
11351 
11352       System.out.flush();
11353       output = new String(baos.toByteArray());
11354 
11355       System.setOut(systemOut);
11356 
11357       outputLines = GrouperClientUtils.splitTrim(output, "\n");
11358 
11359       outputLine = outputLines[0];
11360 
11361       matcher = pattern.matcher(outputLines[0]);
11362 
11363       assertTrue(outputLine, matcher.matches());
11364       assertEquals(outputLine, "0", matcher.group(1));
11365       assertEquals(outputLine, "group", matcher.group(2));
11366       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
11367       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
11368       assertEquals(outputLine, "assign", matcher.group(5));
11369       assertEquals(outputLine, "none", matcher.group(6));
11370       assertEquals(outputLine, "T", matcher.group(7));
11371       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
11372 
11373       assertTrue(GrouperClientWs.mostRecentRequest,
11374           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
11375       assertTrue(GrouperClientWs.mostRecentRequest,
11376           !GrouperClientWs.mostRecentRequest.contains("actions"));
11377       assertTrue(GrouperClientWs.mostRecentRequest,
11378           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
11379       assertTrue(GrouperClientWs.mostRecentRequest,
11380           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
11381       assertTrue(GrouperClientWs.mostRecentRequest,
11382           !GrouperClientWs.mostRecentRequest.contains("enabled"));
11383       assertTrue(GrouperClientWs.mostRecentRequest,
11384           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
11385       assertTrue(GrouperClientWs.mostRecentRequest,
11386           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
11387       assertTrue(GrouperClientWs.mostRecentRequest,
11388           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
11389       assertTrue(GrouperClientWs.mostRecentRequest,
11390           !GrouperClientWs.mostRecentRequest.contains("params"));
11391       assertTrue(GrouperClientWs.mostRecentRequest,
11392           GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames")
11393           && GrouperClientWs.mostRecentRequest.contains("abc"));
11394       assertTrue(GrouperClientWs.mostRecentRequest,
11395           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
11396       assertTrue(GrouperClientWs.mostRecentRequest,
11397           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
11398       assertTrue(GrouperClientWs.mostRecentRequest,
11399           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
11400       assertTrue(GrouperClientWs.mostRecentRequest,
11401           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
11402       assertTrue(GrouperClientWs.mostRecentRequest,
11403           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
11404       assertTrue(GrouperClientWs.mostRecentRequest,
11405           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
11406       assertTrue(GrouperClientWs.mostRecentRequest,
11407           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
11408       assertTrue(GrouperClientWs.mostRecentRequest,
11409           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
11410       assertTrue(GrouperClientWs.mostRecentRequest,
11411           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
11412 
11413 
11414 
11415 
11416       // ######################################################
11417       // Try params
11418 
11419       baos = new ByteArrayOutputStream();
11420       System.setOut(new PrintStream(baos));
11421 
11422       GrouperClient.main(GrouperClientUtils.splitTrim(
11423           "--operation=getAttributeAssignmentsWs --attributeAssignType=group --ownerGroupUuids=" + group.getId()
11424           + " --paramName0=a --paramValue0=b",
11425           " "));
11426 
11427 
11428       System.out.flush();
11429       output = new String(baos.toByteArray());
11430 
11431       System.setOut(systemOut);
11432 
11433       outputLines = GrouperClientUtils.splitTrim(output, "\n");
11434 
11435       outputLine = outputLines[0];
11436 
11437       matcher = pattern.matcher(outputLines[0]);
11438 
11439       assertTrue(outputLine, matcher.matches());
11440       assertEquals(outputLine, "0", matcher.group(1));
11441       assertEquals(outputLine, "group", matcher.group(2));
11442       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
11443       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
11444       assertEquals(outputLine, "assign", matcher.group(5));
11445       assertEquals(outputLine, "none", matcher.group(6));
11446       assertEquals(outputLine, "T", matcher.group(7));
11447       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
11448 
11449       assertTrue(GrouperClientWs.mostRecentRequest,
11450           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
11451       assertTrue(GrouperClientWs.mostRecentRequest,
11452           !GrouperClientWs.mostRecentRequest.contains("actions"));
11453       assertTrue(GrouperClientWs.mostRecentRequest,
11454           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
11455       assertTrue(GrouperClientWs.mostRecentRequest,
11456           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
11457       assertTrue(GrouperClientWs.mostRecentRequest,
11458           !GrouperClientWs.mostRecentRequest.contains("enabled"));
11459       assertTrue(GrouperClientWs.mostRecentRequest,
11460           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
11461       assertTrue(GrouperClientWs.mostRecentRequest,
11462           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
11463       assertTrue(GrouperClientWs.mostRecentRequest,
11464           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
11465       assertTrue(GrouperClientWs.mostRecentRequest,
11466           GrouperClientWs.mostRecentRequest.contains("params"));
11467       assertTrue(GrouperClientWs.mostRecentRequest,
11468           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
11469       assertTrue(GrouperClientWs.mostRecentRequest,
11470           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
11471       assertTrue(GrouperClientWs.mostRecentRequest,
11472           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
11473       assertTrue(GrouperClientWs.mostRecentRequest,
11474           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
11475       assertTrue(GrouperClientWs.mostRecentRequest,
11476           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
11477       assertTrue(GrouperClientWs.mostRecentRequest,
11478           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
11479       assertTrue(GrouperClientWs.mostRecentRequest,
11480           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
11481       assertTrue(GrouperClientWs.mostRecentRequest,
11482           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
11483       assertTrue(GrouperClientWs.mostRecentRequest,
11484           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
11485       assertTrue(GrouperClientWs.mostRecentRequest,
11486           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
11487 
11488 
11489 
11490       // ######################################################
11491       // Try attributeAssignLookups
11492 
11493       baos = new ByteArrayOutputStream();
11494       System.setOut(new PrintStream(baos));
11495 
11496       GrouperClient.main(GrouperClientUtils.splitTrim(
11497           "--operation=getAttributeAssignmentsWs --attributeAssignType=group --attributeAssignUuids=" + attributeAssign.getId(),
11498           " "));
11499 
11500 
11501       System.out.flush();
11502       output = new String(baos.toByteArray());
11503 
11504       System.setOut(systemOut);
11505 
11506       outputLines = GrouperClientUtils.splitTrim(output, "\n");
11507 
11508       outputLine = outputLines[0];
11509 
11510       matcher = pattern.matcher(outputLines[0]);
11511 
11512       assertTrue(outputLine, matcher.matches());
11513       assertEquals(outputLine, "0", matcher.group(1));
11514       assertEquals(outputLine, "group", matcher.group(2));
11515       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
11516       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
11517       assertEquals(outputLine, "assign", matcher.group(5));
11518       assertEquals(outputLine, "none", matcher.group(6));
11519       assertEquals(outputLine, "T", matcher.group(7));
11520       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
11521 
11522       assertTrue(GrouperClientWs.mostRecentRequest,
11523           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
11524       assertTrue(GrouperClientWs.mostRecentRequest,
11525           !GrouperClientWs.mostRecentRequest.contains("actions"));
11526       assertTrue(GrouperClientWs.mostRecentRequest,
11527           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
11528       assertTrue(GrouperClientWs.mostRecentRequest,
11529           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
11530       assertTrue(GrouperClientWs.mostRecentRequest,
11531           !GrouperClientWs.mostRecentRequest.contains("enabled"));
11532       assertTrue(GrouperClientWs.mostRecentRequest,
11533           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
11534       assertTrue(GrouperClientWs.mostRecentRequest,
11535           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
11536       assertTrue(GrouperClientWs.mostRecentRequest,
11537           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
11538       assertTrue(GrouperClientWs.mostRecentRequest,
11539           !GrouperClientWs.mostRecentRequest.contains("params"));
11540       assertTrue(GrouperClientWs.mostRecentRequest,
11541           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
11542       assertTrue(GrouperClientWs.mostRecentRequest,
11543           GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
11544       assertTrue(GrouperClientWs.mostRecentRequest,
11545           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
11546       assertTrue(GrouperClientWs.mostRecentRequest,
11547           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
11548       assertTrue(GrouperClientWs.mostRecentRequest,
11549           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
11550       assertTrue(GrouperClientWs.mostRecentRequest,
11551           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
11552       assertTrue(GrouperClientWs.mostRecentRequest,
11553           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
11554       assertTrue(GrouperClientWs.mostRecentRequest,
11555           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
11556       assertTrue(GrouperClientWs.mostRecentRequest,
11557           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
11558       assertTrue(GrouperClientWs.mostRecentRequest,
11559           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
11560 
11561 
11562 
11563       // ######################################################
11564       // Try attributeAssignLookups custom template
11565 
11566       baos = new ByteArrayOutputStream();
11567       System.setOut(new PrintStream(baos));
11568 
11569       GrouperClient.main(GrouperClientUtils.splitTrim(
11570           "--operation=getAttributeAssignmentsWs --attributeAssignType=group --attributeAssignUuids=" + attributeAssign.getId()
11571           + " --outputTemplate=${wsAttributeAssign.attributeAssignType}$newline$",
11572           " "));
11573 
11574 
11575       System.out.flush();
11576       output = new String(baos.toByteArray());
11577 
11578       System.setOut(systemOut);
11579 
11580       outputLines = GrouperClientUtils.splitTrim(output, "\n");
11581 
11582       outputLine = GrouperClientUtils.trim(outputLines[0]);
11583 
11584       assertEquals(outputLine, "group", outputLine);
11585 
11586       assertTrue(GrouperClientWs.mostRecentRequest,
11587           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
11588       assertTrue(GrouperClientWs.mostRecentRequest,
11589           !GrouperClientWs.mostRecentRequest.contains("actions"));
11590       assertTrue(GrouperClientWs.mostRecentRequest,
11591           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
11592       assertTrue(GrouperClientWs.mostRecentRequest,
11593           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
11594       assertTrue(GrouperClientWs.mostRecentRequest,
11595           !GrouperClientWs.mostRecentRequest.contains("enabled"));
11596       assertTrue(GrouperClientWs.mostRecentRequest,
11597           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
11598       assertTrue(GrouperClientWs.mostRecentRequest,
11599           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
11600       assertTrue(GrouperClientWs.mostRecentRequest,
11601           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
11602       assertTrue(GrouperClientWs.mostRecentRequest,
11603           !GrouperClientWs.mostRecentRequest.contains("params"));
11604       assertTrue(GrouperClientWs.mostRecentRequest,
11605           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
11606       assertTrue(GrouperClientWs.mostRecentRequest,
11607           GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
11608       assertTrue(GrouperClientWs.mostRecentRequest,
11609           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
11610       assertTrue(GrouperClientWs.mostRecentRequest,
11611           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
11612       assertTrue(GrouperClientWs.mostRecentRequest,
11613           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
11614       assertTrue(GrouperClientWs.mostRecentRequest,
11615           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
11616       assertTrue(GrouperClientWs.mostRecentRequest,
11617           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
11618       assertTrue(GrouperClientWs.mostRecentRequest,
11619           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
11620       assertTrue(GrouperClientWs.mostRecentRequest,
11621           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
11622       assertTrue(GrouperClientWs.mostRecentRequest,
11623           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
11624 
11625 
11626       // ######################################################
11627       // Try actAs
11628 
11629       baos = new ByteArrayOutputStream();
11630       System.setOut(new PrintStream(baos));
11631 
11632       GrouperClient.main(GrouperClientUtils.splitTrim(
11633           "--operation=getAttributeAssignmentsWs --attributeAssignType=group --attributeAssignUuids=" + attributeAssign.getId()
11634           + " --actAsSubjectId=GrouperSystem",
11635           " "));
11636 
11637 
11638       System.out.flush();
11639       output = new String(baos.toByteArray());
11640 
11641       System.setOut(systemOut);
11642 
11643       outputLines = GrouperClientUtils.splitTrim(output, "\n");
11644 
11645       outputLine = outputLines[0];
11646 
11647       matcher = pattern.matcher(outputLines[0]);
11648 
11649       assertTrue(outputLine, matcher.matches());
11650       assertEquals(outputLine, "0", matcher.group(1));
11651       assertEquals(outputLine, "group", matcher.group(2));
11652       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
11653       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
11654       assertEquals(outputLine, "assign", matcher.group(5));
11655       assertEquals(outputLine, "none", matcher.group(6));
11656       assertEquals(outputLine, "T", matcher.group(7));
11657       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
11658 
11659       assertTrue(GrouperClientWs.mostRecentRequest,
11660           GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
11661       assertTrue(GrouperClientWs.mostRecentRequest,
11662           !GrouperClientWs.mostRecentRequest.contains("actions"));
11663       assertTrue(GrouperClientWs.mostRecentRequest,
11664           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
11665       assertTrue(GrouperClientWs.mostRecentRequest,
11666           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
11667       assertTrue(GrouperClientWs.mostRecentRequest,
11668           !GrouperClientWs.mostRecentRequest.contains("enabled"));
11669       assertTrue(GrouperClientWs.mostRecentRequest,
11670           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
11671       assertTrue(GrouperClientWs.mostRecentRequest,
11672           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
11673       assertTrue(GrouperClientWs.mostRecentRequest,
11674           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
11675       assertTrue(GrouperClientWs.mostRecentRequest,
11676           !GrouperClientWs.mostRecentRequest.contains("params"));
11677       assertTrue(GrouperClientWs.mostRecentRequest,
11678           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
11679       assertTrue(GrouperClientWs.mostRecentRequest,
11680           GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
11681       assertTrue(GrouperClientWs.mostRecentRequest,
11682           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
11683       assertTrue(GrouperClientWs.mostRecentRequest,
11684           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
11685       assertTrue(GrouperClientWs.mostRecentRequest,
11686           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
11687       assertTrue(GrouperClientWs.mostRecentRequest,
11688           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
11689       assertTrue(GrouperClientWs.mostRecentRequest,
11690           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
11691       assertTrue(GrouperClientWs.mostRecentRequest,
11692           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
11693       assertTrue(GrouperClientWs.mostRecentRequest,
11694           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
11695       assertTrue(GrouperClientWs.mostRecentRequest,
11696           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
11697 
11698 
11699 
11700 
11701 
11702     } finally {
11703       System.setOut(systemOut);
11704     }
11705 
11706   }
11707   
11708   /**
11709    * @throws Exception
11710    */
11711   public void testGetAttributeAssignActions() throws Exception {
11712 
11713     AttributeDefName nameOfAttributeDef = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
11714 
11715     final AttributeDef attributeDef = nameOfAttributeDef.getAttributeDef();
11716     attributeDef.getAttributeDefActionDelegate().addAction("read");
11717     attributeDef.store();
11718 
11719     PrintStream systemOut = System.out;
11720 
11721     ByteArrayOutputStream baos = new ByteArrayOutputStream();
11722     System.setOut(new PrintStream(baos));
11723 
11724     try {
11725 
11726       GrouperClient.main(GrouperClientUtils.splitTrim(
11727           "--operation=getAttributeAssignActionsWs --namesOfAttributeDefs=test:testAttributeAssignDefNameDef",
11728           " "));
11729       System.out.flush();
11730       String output = new String(baos.toByteArray());
11731 
11732       System.setOut(systemOut);
11733 
11734       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
11735 
11736       Pattern pattern = Pattern
11737           .compile("^Index: (\\d+)\\: nameOfAttributeDef\\: (.+), action: (.+)$");
11738       String outputLine = outputLines[0];
11739 
11740       Matcher matcher = pattern.matcher(outputLines[0]);
11741 
11742       assertTrue(outputLine, matcher.matches());
11743       assertEquals(outputLine, "0", matcher.group(1));
11744       assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
11745       assertTrue(outputLine, matcher.group(3).equals("read") || matcher.group(3).equals("assign"));
11746       
11747       outputLine = outputLines[1];
11748       matcher = pattern.matcher(outputLines[1]);
11749 
11750       assertTrue(outputLine, matcher.matches());
11751       assertEquals(outputLine, "1", matcher.group(1));
11752       assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
11753       assertTrue(outputLine, matcher.group(3).equals("read") || matcher.group(3).equals("assign"));
11754 
11755       assertTrue(GrouperClientWs.mostRecentRequest,
11756           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
11757       assertTrue(GrouperClientWs.mostRecentRequest,
11758           !GrouperClientWs.mostRecentRequest.contains("actions"));
11759       assertTrue(GrouperClientWs.mostRecentRequest,
11760           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
11761       assertTrue(GrouperClientWs.mostRecentRequest,
11762           !GrouperClientWs.mostRecentRequest.contains("params"));
11763       assertTrue(GrouperClientWs.mostRecentRequest,
11764           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
11765       assertTrue(GrouperClientWs.mostRecentRequest,
11766           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
11767 
11768       // ######################################################
11769       // Try attributeDefId
11770 
11771       baos = new ByteArrayOutputStream();
11772       System.setOut(new PrintStream(baos));
11773 
11774       GrouperClient.main(GrouperClientUtils.splitTrim(
11775           "--operation=getAttributeAssignActionsWs --uuidsOfAttributeDefs=" + attributeDef.getId(),
11776           " "));
11777 
11778 
11779       System.out.flush();
11780       output = new String(baos.toByteArray());
11781 
11782       System.setOut(systemOut);
11783 
11784       outputLines = GrouperClientUtils.splitTrim(output, "\n");
11785 
11786       outputLine = outputLines[0];
11787 
11788       matcher = pattern.matcher(outputLines[0]);
11789 
11790       assertTrue(outputLine, matcher.matches());
11791       assertEquals(outputLine, "0", matcher.group(1));
11792       assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
11793       assertEquals(outputLine, "read", matcher.group(3));
11794       
11795       outputLine = outputLines[1];
11796       matcher = pattern.matcher(outputLines[1]);
11797 
11798       assertTrue(outputLine, matcher.matches());
11799       assertEquals(outputLine, "1", matcher.group(1));
11800       assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
11801       assertEquals(outputLine, "assign", matcher.group(3));
11802 
11803       assertTrue(GrouperClientWs.mostRecentRequest,
11804           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
11805       assertTrue(GrouperClientWs.mostRecentRequest,
11806           !GrouperClientWs.mostRecentRequest.contains("actions"));
11807       assertTrue(GrouperClientWs.mostRecentRequest,
11808           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
11809       assertTrue(GrouperClientWs.mostRecentRequest,
11810           !GrouperClientWs.mostRecentRequest.contains("params"));
11811       assertTrue(GrouperClientWs.mostRecentRequest,
11812           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
11813 
11814       // ######################################################
11815       // Try attributeDefIdIndex
11816 
11817       baos = new ByteArrayOutputStream();
11818       System.setOut(new PrintStream(baos));
11819 
11820       GrouperClient.main(GrouperClientUtils.splitTrim(
11821           "--operation=getAttributeAssignActionsWs --idIndexesOfAttributeDefs=" + attributeDef.getIdIndex(),
11822           " "));
11823 
11824 
11825       System.out.flush();
11826       output = new String(baos.toByteArray());
11827 
11828       System.setOut(systemOut);
11829 
11830       outputLines = GrouperClientUtils.splitTrim(output, "\n");
11831 
11832       outputLine = outputLines[0];
11833 
11834       matcher = pattern.matcher(outputLines[0]);
11835 
11836       assertTrue(outputLine, matcher.matches());
11837       assertEquals(outputLine, "0", matcher.group(1));
11838       assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
11839       assertTrue(outputLine, matcher.group(3).equals("read") || matcher.group(3).equals("assign"));
11840       
11841       outputLine = outputLines[1];
11842       matcher = pattern.matcher(outputLines[1]);
11843 
11844       assertTrue(outputLine, matcher.matches());
11845       assertEquals(outputLine, "1", matcher.group(1));
11846       assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
11847       assertTrue(outputLine, matcher.group(3).equals("read") || matcher.group(3).equals("assign"));
11848 
11849       assertTrue(GrouperClientWs.mostRecentRequest,
11850           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
11851       assertTrue(GrouperClientWs.mostRecentRequest,
11852           !GrouperClientWs.mostRecentRequest.contains("actions"));
11853       assertTrue(GrouperClientWs.mostRecentRequest,
11854           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
11855       assertTrue(GrouperClientWs.mostRecentRequest,
11856           !GrouperClientWs.mostRecentRequest.contains("params"));
11857       assertTrue(GrouperClientWs.mostRecentRequest,
11858           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<idIndex>"));
11859 
11860       // ######################################################
11861       // Try actions
11862 
11863       baos = new ByteArrayOutputStream();
11864       System.setOut(new PrintStream(baos));
11865 
11866       GrouperClient.main(GrouperClientUtils.splitTrim(
11867           "--operation=getAttributeAssignActionsWs --idIndexesOfAttributeDefs=" + attributeDef.getIdIndex() +" --actions=read", " "));
11868 
11869 
11870       System.out.flush();
11871       output = new String(baos.toByteArray());
11872 
11873       System.setOut(systemOut);
11874 
11875       outputLines = GrouperClientUtils.splitTrim(output, "\n");
11876 
11877       assertTrue(outputLines.length == 1);
11878 
11879       assertTrue(GrouperClientWs.mostRecentRequest,
11880           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
11881       assertTrue(GrouperClientWs.mostRecentRequest,
11882           GrouperClientWs.mostRecentRequest.contains("actions"));
11883       assertTrue(GrouperClientWs.mostRecentRequest,
11884           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
11885       assertTrue(GrouperClientWs.mostRecentRequest,
11886           !GrouperClientWs.mostRecentRequest.contains("params"));
11887       assertTrue(GrouperClientWs.mostRecentRequest,
11888           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
11889       
11890       // ######################################################
11891       // Try params
11892 
11893       baos = new ByteArrayOutputStream();
11894       System.setOut(new PrintStream(baos));
11895 
11896       GrouperClient.main(GrouperClientUtils.splitTrim(
11897           "--operation=getAttributeAssignActionsWs --idIndexesOfAttributeDefs=" + attributeDef.getIdIndex() +" --paramName0=a --paramValue0=b",
11898           " "));
11899 
11900 
11901       System.out.flush();
11902       output = new String(baos.toByteArray());
11903 
11904       System.setOut(systemOut);
11905 
11906       outputLines = GrouperClientUtils.splitTrim(output, "\n");
11907 
11908       outputLine = outputLines[0];
11909 
11910       matcher = pattern.matcher(outputLines[0]);
11911 
11912       assertTrue(outputLine, matcher.matches());
11913       assertEquals(outputLine, "0", matcher.group(1));
11914       assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
11915       assertTrue(outputLine, matcher.group(3).equals("read") || matcher.group(3).equals("assign"));
11916       
11917       outputLine = outputLines[1];
11918       matcher = pattern.matcher(outputLines[1]);
11919 
11920       assertTrue(outputLine, matcher.matches());
11921       assertEquals(outputLine, "1", matcher.group(1));
11922       assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
11923       assertTrue(outputLine, matcher.group(3).equals("read") || matcher.group(3).equals("assign"));
11924 
11925       assertTrue(GrouperClientWs.mostRecentRequest,
11926           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
11927       assertTrue(GrouperClientWs.mostRecentRequest,
11928           !GrouperClientWs.mostRecentRequest.contains("actions"));
11929       assertTrue(GrouperClientWs.mostRecentRequest,
11930           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
11931       assertTrue(GrouperClientWs.mostRecentRequest,
11932           GrouperClientWs.mostRecentRequest.contains("params"));
11933       assertTrue(GrouperClientWs.mostRecentRequest,
11934           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
11935       
11936       // ######################################################
11937       // Try actAs
11938 
11939       baos = new ByteArrayOutputStream();
11940       System.setOut(new PrintStream(baos));
11941 
11942       GrouperClient.main(GrouperClientUtils.splitTrim(
11943           "--operation=getAttributeAssignActionsWs --idIndexesOfAttributeDefs=" + attributeDef.getIdIndex() +" --actAsSubjectId=GrouperSystem", " "));
11944 
11945 
11946       System.out.flush();
11947       output = new String(baos.toByteArray());
11948 
11949       System.setOut(systemOut);
11950 
11951       outputLines = GrouperClientUtils.splitTrim(output, "\n");
11952 
11953       outputLine = outputLines[0];
11954 
11955       matcher = pattern.matcher(outputLines[0]);
11956 
11957       assertTrue(outputLine, matcher.matches());
11958       assertEquals(outputLine, "0", matcher.group(1));
11959       assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
11960       assertTrue(outputLine, matcher.group(3).equals("read") || matcher.group(3).equals("assign"));
11961       
11962       outputLine = outputLines[1];
11963       matcher = pattern.matcher(outputLines[1]);
11964 
11965       assertTrue(outputLine, matcher.matches());
11966       assertEquals(outputLine, "1", matcher.group(1));
11967       assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
11968       assertTrue(outputLine, matcher.group(3).equals("read") || matcher.group(3).equals("assign"));
11969 
11970       assertTrue(GrouperClientWs.mostRecentRequest,
11971           GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
11972       assertTrue(GrouperClientWs.mostRecentRequest,
11973           !GrouperClientWs.mostRecentRequest.contains("actions"));
11974       assertTrue(GrouperClientWs.mostRecentRequest,
11975           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
11976       assertTrue(GrouperClientWs.mostRecentRequest,
11977           !GrouperClientWs.mostRecentRequest.contains("params"));
11978       assertTrue(GrouperClientWs.mostRecentRequest,
11979           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
11980       
11981     } finally {
11982       System.setOut(systemOut);
11983     }
11984 
11985   }
11986   
11987   /**
11988    * @throws Exception
11989    */
11990   public void testAssignActionsToAttributeDef() throws Exception {
11991 
11992     AttributeDefName nameOfAttributeDef = AttributeDefNameTest.exampleAttributeDefNameDb(
11993         "test", "testAttributeAssignDefName");
11994 
11995     final AttributeDef attributeDef = nameOfAttributeDef.getAttributeDef();
11996 
11997     PrintStream systemOut = System.out;
11998 
11999     ByteArrayOutputStream baos = new ByteArrayOutputStream();
12000     System.setOut(new PrintStream(baos));
12001 
12002     try {
12003 
12004       GrouperClient
12005           .main(GrouperClientUtils
12006               .splitTrim(
12007                   "--operation=assignAttributeDefActionsWs --nameOfAttributeDef=test:testAttributeAssignDefNameDef --actions=read,assign --assign=T",
12008                   " "));
12009       System.out.flush();
12010       String output = new String(baos.toByteArray());
12011 
12012       System.setOut(systemOut);
12013 
12014       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
12015 
12016       Pattern pattern = Pattern
12017           .compile("^Index (\\d+)\\: nameOfAttributeDef\\: (.+), action: (.+), status: (.+)$");
12018       String outputLine = outputLines[0];
12019 
12020       Matcher matcher = pattern.matcher(outputLines[0]);
12021 
12022       assertTrue(outputLine, matcher.matches());
12023       assertEquals(outputLine, "0", matcher.group(1));
12024       assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
12025       assertEquals(outputLine, "read", matcher.group(3));
12026       assertEquals(outputLine, "ADDED", matcher.group(4));
12027 
12028       outputLine = outputLines[1];
12029       matcher = pattern.matcher(outputLines[1]);
12030 
12031       assertTrue(outputLine, matcher.matches());
12032       assertEquals(outputLine, "1", matcher.group(1));
12033       assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
12034       assertEquals(outputLine, "assign", matcher.group(3));
12035       assertEquals(outputLine, "ASSIGNED_ALREADY", matcher.group(4));
12036 
12037       assertTrue(GrouperClientWs.mostRecentRequest,
12038           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
12039       assertTrue(GrouperClientWs.mostRecentRequest,
12040           GrouperClientWs.mostRecentRequest.contains("actions"));
12041       assertTrue(GrouperClientWs.mostRecentRequest,
12042           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
12043       assertTrue(GrouperClientWs.mostRecentRequest,
12044           !GrouperClientWs.mostRecentRequest.contains("params"));
12045       assertTrue(GrouperClientWs.mostRecentRequest,
12046           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookup")
12047               && GrouperClientWs.mostRecentRequest.contains("<name>"));
12048 
12049       // ######################################################
12050       // Try attributeDefId
12051 
12052       baos = new ByteArrayOutputStream();
12053       System.setOut(new PrintStream(baos));
12054 
12055       GrouperClient.main(GrouperClientUtils.splitTrim(
12056           "--operation=assignAttributeDefActionsWs --uuidOfAttributeDef="
12057               + attributeDef.getId() + " --actions=read,assign --assign=T",
12058           " "));
12059 
12060       System.out.flush();
12061       output = new String(baos.toByteArray());
12062 
12063       System.setOut(systemOut);
12064 
12065       outputLines = GrouperClientUtils.splitTrim(output, "\n");
12066 
12067       outputLine = outputLines[0];
12068 
12069       matcher = pattern.matcher(outputLines[0]);
12070 
12071       assertTrue(outputLine, matcher.matches());
12072       assertEquals(outputLine, "0", matcher.group(1));
12073       assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
12074       assertEquals(outputLine, "read", matcher.group(3));
12075       assertEquals(outputLine, "ASSIGNED_ALREADY", matcher.group(4));
12076 
12077       outputLine = outputLines[1];
12078       matcher = pattern.matcher(outputLines[1]);
12079 
12080       assertTrue(outputLine, matcher.matches());
12081       assertEquals(outputLine, "1", matcher.group(1));
12082       assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
12083       assertEquals(outputLine, "assign", matcher.group(3));
12084       assertEquals(outputLine, "ASSIGNED_ALREADY", matcher.group(4));
12085 
12086       assertTrue(GrouperClientWs.mostRecentRequest,
12087           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
12088       assertTrue(GrouperClientWs.mostRecentRequest,
12089           GrouperClientWs.mostRecentRequest.contains("actions"));
12090       assertTrue(GrouperClientWs.mostRecentRequest,
12091           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
12092       assertTrue(GrouperClientWs.mostRecentRequest,
12093           !GrouperClientWs.mostRecentRequest.contains("params"));
12094       assertTrue(GrouperClientWs.mostRecentRequest,
12095           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookup")
12096               && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
12097 
12098       // ######################################################
12099       // Try attributeDefIdIndex
12100 
12101       baos = new ByteArrayOutputStream();
12102       System.setOut(new PrintStream(baos));
12103 
12104       GrouperClient.main(GrouperClientUtils.splitTrim(
12105           "--operation=assignAttributeDefActionsWs --idIndexOfAttributeDef="
12106               + attributeDef.getIdIndex() + " --actions=delete,assign --assign=T",
12107           " "));
12108 
12109       System.out.flush();
12110       output = new String(baos.toByteArray());
12111 
12112       System.setOut(systemOut);
12113 
12114       outputLines = GrouperClientUtils.splitTrim(output, "\n");
12115 
12116       outputLine = outputLines[0];
12117 
12118       matcher = pattern.matcher(outputLines[0]);
12119 
12120       assertTrue(outputLine, matcher.matches());
12121       assertEquals(outputLine, "0", matcher.group(1));
12122       assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
12123       assertEquals(outputLine, "delete", matcher.group(3));
12124       assertEquals(outputLine, "ADDED", matcher.group(4));
12125 
12126       outputLine = outputLines[1];
12127       matcher = pattern.matcher(outputLines[1]);
12128 
12129       assertTrue(outputLine, matcher.matches());
12130       assertEquals(outputLine, "1", matcher.group(1));
12131       assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
12132       assertEquals(outputLine, "assign", matcher.group(3));
12133       assertEquals(outputLine, "ASSIGNED_ALREADY", matcher.group(4));
12134 
12135       assertTrue(GrouperClientWs.mostRecentRequest,
12136           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
12137       assertTrue(GrouperClientWs.mostRecentRequest,
12138           GrouperClientWs.mostRecentRequest.contains("actions"));
12139       assertTrue(GrouperClientWs.mostRecentRequest,
12140           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
12141       assertTrue(GrouperClientWs.mostRecentRequest,
12142           !GrouperClientWs.mostRecentRequest.contains("params"));
12143       assertTrue(GrouperClientWs.mostRecentRequest,
12144           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookup")
12145               && GrouperClientWs.mostRecentRequest.contains("<idIndex>"));
12146 
12147       // ######################################################
12148       // Try replacing actions
12149 
12150       baos = new ByteArrayOutputStream();
12151       System.setOut(new PrintStream(baos));
12152 
12153       GrouperClient.main(GrouperClientUtils.splitTrim(
12154           "--operation=assignAttributeDefActionsWs --idIndexOfAttributeDef="
12155               + attributeDef.getIdIndex()
12156               + " --actions=view --assign=T --replaceAllExisting=T",
12157           " "));
12158 
12159       System.out.flush();
12160       output = new String(baos.toByteArray());
12161 
12162       System.setOut(systemOut);
12163 
12164       outputLines = GrouperClientUtils.splitTrim(output, "\n");
12165 
12166       outputLine = outputLines[0];
12167 
12168       matcher = pattern.matcher(outputLines[0]);
12169 
12170       List<String> existingActions = new ArrayList<String>();
12171       existingActions.add("read");
12172       existingActions.add("assign");
12173       existingActions.add("delete");
12174 
12175       assertTrue(outputLine, matcher.matches());
12176       assertEquals(outputLine, "0", matcher.group(1));
12177       assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
12178       assertTrue(outputLine, existingActions.contains(matcher.group(3)));
12179       assertEquals(outputLine, "DELETED", matcher.group(4));
12180 
12181       outputLine = outputLines[1];
12182       matcher = pattern.matcher(outputLines[1]);
12183 
12184       assertTrue(outputLine, matcher.matches());
12185       assertEquals(outputLine, "1", matcher.group(1));
12186       assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
12187       assertTrue(outputLine, existingActions.contains(matcher.group(3)));
12188       assertEquals(outputLine, "DELETED", matcher.group(4));
12189 
12190       outputLine = outputLines[2];
12191       matcher = pattern.matcher(outputLines[2]);
12192 
12193       assertTrue(outputLine, matcher.matches());
12194       assertEquals(outputLine, "2", matcher.group(1));
12195       assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
12196       assertTrue(outputLine, existingActions.contains(matcher.group(3)));
12197       assertEquals(outputLine, "DELETED", matcher.group(4));
12198 
12199       outputLine = outputLines[3];
12200       matcher = pattern.matcher(outputLines[3]);
12201 
12202       assertTrue(outputLine, matcher.matches());
12203       assertEquals(outputLine, "3", matcher.group(1));
12204       assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
12205       assertEquals(outputLine, "view", matcher.group(3));
12206       assertEquals(outputLine, "ADDED", matcher.group(4));
12207 
12208       assertTrue(GrouperClientWs.mostRecentRequest,
12209           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
12210       assertTrue(GrouperClientWs.mostRecentRequest,
12211           GrouperClientWs.mostRecentRequest.contains("actions"));
12212       assertTrue(GrouperClientWs.mostRecentRequest,
12213           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
12214       assertTrue(GrouperClientWs.mostRecentRequest,
12215           !GrouperClientWs.mostRecentRequest.contains("params"));
12216       assertTrue(GrouperClientWs.mostRecentRequest,
12217           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookup")
12218               && GrouperClientWs.mostRecentRequest.contains("<idIndex>"));
12219 
12220       // ######################################################
12221       // Try removing actions
12222 
12223       baos = new ByteArrayOutputStream();
12224       System.setOut(new PrintStream(baos));
12225 
12226       GrouperClient.main(GrouperClientUtils.splitTrim(
12227           "--operation=assignAttributeDefActionsWs --idIndexOfAttributeDef="
12228               + attributeDef.getIdIndex() + " --actions=view --assign=F",
12229           " "));
12230 
12231       System.out.flush();
12232       output = new String(baos.toByteArray());
12233 
12234       System.setOut(systemOut);
12235 
12236       outputLines = GrouperClientUtils.splitTrim(output, "\n");
12237 
12238       outputLine = outputLines[0];
12239 
12240       matcher = pattern.matcher(outputLines[0]);
12241 
12242       assertTrue(outputLine, matcher.matches());
12243       assertEquals(outputLine, "0", matcher.group(1));
12244       assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
12245       assertEquals(outputLine, "view", matcher.group(3));
12246       assertEquals(outputLine, "DELETED", matcher.group(4));
12247 
12248       assertTrue(GrouperClientWs.mostRecentRequest,
12249           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
12250       assertTrue(GrouperClientWs.mostRecentRequest,
12251           GrouperClientWs.mostRecentRequest.contains("actions"));
12252       assertTrue(GrouperClientWs.mostRecentRequest,
12253           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
12254       assertTrue(GrouperClientWs.mostRecentRequest,
12255           !GrouperClientWs.mostRecentRequest.contains("params"));
12256       assertTrue(GrouperClientWs.mostRecentRequest,
12257           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookup")
12258               && GrouperClientWs.mostRecentRequest.contains("<idIndex>"));
12259 
12260       // ######################################################
12261       // Try params
12262 
12263       baos = new ByteArrayOutputStream();
12264       System.setOut(new PrintStream(baos));
12265 
12266       GrouperClient.main(GrouperClientUtils.splitTrim(
12267           "--operation=assignAttributeDefActionsWs --idIndexOfAttributeDef="
12268               + attributeDef.getIdIndex()
12269               + " --actions=view --assign=T --paramName0=a --paramValue0=b",
12270           " "));
12271 
12272       System.out.flush();
12273       output = new String(baos.toByteArray());
12274 
12275       System.setOut(systemOut);
12276 
12277       outputLines = GrouperClientUtils.splitTrim(output, "\n");
12278 
12279       outputLine = outputLines[0];
12280 
12281       matcher = pattern.matcher(outputLines[0]);
12282 
12283       assertTrue(outputLine, matcher.matches());
12284       assertEquals(outputLine, "0", matcher.group(1));
12285       assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
12286       assertEquals(outputLine, "view", matcher.group(3));
12287       assertEquals(outputLine, "ADDED", matcher.group(4));
12288 
12289       assertTrue(GrouperClientWs.mostRecentRequest,
12290           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
12291       assertTrue(GrouperClientWs.mostRecentRequest,
12292           GrouperClientWs.mostRecentRequest.contains("actions"));
12293       assertTrue(GrouperClientWs.mostRecentRequest,
12294           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
12295       assertTrue(GrouperClientWs.mostRecentRequest,
12296           GrouperClientWs.mostRecentRequest.contains("params"));
12297       assertTrue(GrouperClientWs.mostRecentRequest,
12298           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookup")
12299               && GrouperClientWs.mostRecentRequest.contains("<idIndex>"));
12300 
12301       // ######################################################
12302       // Try actAs
12303 
12304       baos = new ByteArrayOutputStream();
12305       System.setOut(new PrintStream(baos));
12306 
12307       GrouperClient.main(GrouperClientUtils.splitTrim(
12308           "--operation=assignAttributeDefActionsWs --idIndexOfAttributeDef="
12309               + attributeDef.getIdIndex()
12310               + " --actions=view --assign=T --actAsSubjectId=GrouperSystem",
12311           " "));
12312 
12313       System.out.flush();
12314       output = new String(baos.toByteArray());
12315 
12316       System.setOut(systemOut);
12317 
12318       outputLines = GrouperClientUtils.splitTrim(output, "\n");
12319 
12320       outputLine = outputLines[0];
12321 
12322       matcher = pattern.matcher(outputLines[0]);
12323 
12324       assertTrue(outputLine, matcher.matches());
12325       assertEquals(outputLine, "0", matcher.group(1));
12326       assertEquals(outputLine, "test:testAttributeAssignDefNameDef", matcher.group(2));
12327       assertEquals(outputLine, "view", matcher.group(3));
12328       assertEquals(outputLine, "ASSIGNED_ALREADY", matcher.group(4));
12329 
12330       assertTrue(GrouperClientWs.mostRecentRequest,
12331           GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
12332       assertTrue(GrouperClientWs.mostRecentRequest,
12333           GrouperClientWs.mostRecentRequest.contains("actions"));
12334       assertTrue(GrouperClientWs.mostRecentRequest,
12335           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
12336       assertTrue(GrouperClientWs.mostRecentRequest,
12337           !GrouperClientWs.mostRecentRequest.contains("params"));
12338       assertTrue(GrouperClientWs.mostRecentRequest,
12339           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookup")
12340               && GrouperClientWs.mostRecentRequest.contains("<idIndex>"));
12341 
12342     } finally {
12343       System.setOut(systemOut);
12344     }
12345 
12346   }
12347 
12348   /**
12349    * @throws Exception
12350    */
12351   public void testGetAttributeAssignsStem() throws Exception {
12352 
12353     AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
12354 
12355     final AttributeDef attributeDef = attributeDefName.getAttributeDef();
12356 
12357     attributeDef.setAssignToGroup(false);
12358     attributeDef.setAssignToStem(true);
12359     attributeDef.store();
12360 
12361     Stem stem = new StemSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
12362       .assignStemNameToEdit("test:stemTestAttrAssign").assignName("test:stemTestAttrAssign").assignCreateParentStemsIfNotExist(true)
12363       .assignDescription("description").save();
12364 
12365     AttributeAssignResult attributeAssignResult = stem.getAttributeDelegate().assignAttribute(attributeDefName);
12366     AttributeAssign attributeAssign = attributeAssignResult.getAttributeAssign();
12367 
12368 
12369     PrintStream systemOut = System.out;
12370 
12371     ByteArrayOutputStream baos = new ByteArrayOutputStream();
12372     System.setOut(new PrintStream(baos));
12373 
12374     try {
12375 
12376       GrouperClient.main(GrouperClientUtils.splitTrim(
12377           "--operation=getAttributeAssignmentsWs --attributeAssignType=stem --attributeDefNames=test:testAttributeAssignDefNameDef",
12378           " "));
12379       System.out.flush();
12380       String output = new String(baos.toByteArray());
12381 
12382       System.setOut(systemOut);
12383 
12384       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
12385 
12386       // match: Index: 0: attributeAssignType: stem, owner: test:stemTestAttrAssign, attributeDefNameName test:testAttributeAssignDefName, action: assign, values: none, enable: T, id: a9c83eeb78c04ae5befcea36272d318c
12387       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
12388       Pattern pattern = Pattern
12389           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
12390       String outputLine = outputLines[0];
12391 
12392       Matcher matcher = pattern.matcher(outputLines[0]);
12393 
12394       assertTrue(outputLine, matcher.matches());
12395       assertEquals(outputLine, "0", matcher.group(1));
12396       assertEquals(outputLine, "stem", matcher.group(2));
12397       assertEquals(outputLine, "test:stemTestAttrAssign", matcher.group(3));
12398       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
12399       assertEquals(outputLine, "assign", matcher.group(5));
12400       assertEquals(outputLine, "none", matcher.group(6));
12401       assertEquals(outputLine, "T", matcher.group(7));
12402       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
12403 
12404       assertTrue(GrouperClientWs.mostRecentRequest,
12405           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
12406       assertTrue(GrouperClientWs.mostRecentRequest,
12407           !GrouperClientWs.mostRecentRequest.contains("actions"));
12408       assertTrue(GrouperClientWs.mostRecentRequest,
12409           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
12410       assertTrue(GrouperClientWs.mostRecentRequest,
12411           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
12412       assertTrue(GrouperClientWs.mostRecentRequest,
12413           !GrouperClientWs.mostRecentRequest.contains("enabled"));
12414       assertTrue(GrouperClientWs.mostRecentRequest,
12415           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
12416       assertTrue(GrouperClientWs.mostRecentRequest,
12417           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
12418       assertTrue(GrouperClientWs.mostRecentRequest,
12419           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
12420       assertTrue(GrouperClientWs.mostRecentRequest,
12421           !GrouperClientWs.mostRecentRequest.contains("params"));
12422       assertTrue(GrouperClientWs.mostRecentRequest,
12423           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
12424       assertTrue(GrouperClientWs.mostRecentRequest,
12425           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
12426       assertTrue(GrouperClientWs.mostRecentRequest,
12427           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
12428       assertTrue(GrouperClientWs.mostRecentRequest,
12429           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
12430       assertTrue(GrouperClientWs.mostRecentRequest,
12431           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
12432       assertTrue(GrouperClientWs.mostRecentRequest,
12433           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
12434       assertTrue(GrouperClientWs.mostRecentRequest,
12435           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
12436       assertTrue(GrouperClientWs.mostRecentRequest,
12437           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
12438       assertTrue(GrouperClientWs.mostRecentRequest,
12439           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
12440       assertTrue(GrouperClientWs.mostRecentRequest,
12441           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
12442 
12443       // ######################################################
12444       // Try wsOwnerStemUuids
12445 
12446       baos = new ByteArrayOutputStream();
12447       System.setOut(new PrintStream(baos));
12448 
12449       GrouperClient.main(GrouperClientUtils.splitTrim(
12450           "--operation=getAttributeAssignmentsWs --attributeAssignType=stem --ownerStemUuids=" + stem.getUuid(),
12451           " "));
12452 
12453 
12454       System.out.flush();
12455       output = new String(baos.toByteArray());
12456 
12457       System.setOut(systemOut);
12458 
12459       outputLines = GrouperClientUtils.splitTrim(output, "\n");
12460 
12461       outputLine = outputLines[0];
12462 
12463       matcher = pattern.matcher(outputLine);
12464 
12465       assertTrue(outputLine, matcher.matches());
12466       assertEquals(outputLine, "0", matcher.group(1));
12467       assertEquals(outputLine, "stem", matcher.group(2));
12468       assertEquals(outputLine, "test:stemTestAttrAssign", matcher.group(3));
12469       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
12470       assertEquals(outputLine, "assign", matcher.group(5));
12471       assertEquals(outputLine, "none", matcher.group(6));
12472       assertEquals(outputLine, "T", matcher.group(7));
12473       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
12474 
12475       assertTrue(GrouperClientWs.mostRecentRequest,
12476           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
12477       assertTrue(GrouperClientWs.mostRecentRequest,
12478           !GrouperClientWs.mostRecentRequest.contains("actions"));
12479       assertTrue(GrouperClientWs.mostRecentRequest,
12480           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
12481       assertTrue(GrouperClientWs.mostRecentRequest,
12482           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
12483       assertTrue(GrouperClientWs.mostRecentRequest,
12484           !GrouperClientWs.mostRecentRequest.contains("enabled"));
12485       assertTrue(GrouperClientWs.mostRecentRequest,
12486           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
12487       assertTrue(GrouperClientWs.mostRecentRequest,
12488           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
12489       assertTrue(GrouperClientWs.mostRecentRequest,
12490           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
12491       assertTrue(GrouperClientWs.mostRecentRequest,
12492           !GrouperClientWs.mostRecentRequest.contains("params"));
12493       assertTrue(GrouperClientWs.mostRecentRequest,
12494           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
12495       assertTrue(GrouperClientWs.mostRecentRequest,
12496           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
12497       assertTrue(GrouperClientWs.mostRecentRequest,
12498           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
12499       assertTrue(GrouperClientWs.mostRecentRequest,
12500           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
12501       assertTrue(GrouperClientWs.mostRecentRequest,
12502           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
12503       assertTrue(GrouperClientWs.mostRecentRequest,
12504           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
12505       assertTrue(GrouperClientWs.mostRecentRequest,
12506           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
12507       assertTrue(GrouperClientWs.mostRecentRequest,
12508           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
12509       assertTrue(GrouperClientWs.mostRecentRequest,
12510           GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
12511       assertTrue(GrouperClientWs.mostRecentRequest,
12512           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
12513 
12514 
12515       // ######################################################
12516       // Try wsOwnerStemNames
12517 
12518       baos = new ByteArrayOutputStream();
12519       System.setOut(new PrintStream(baos));
12520 
12521       GrouperClient.main(GrouperClientUtils.splitTrim(
12522           "--operation=getAttributeAssignmentsWs --attributeAssignType=stem --ownerStemNames=" + stem.getName(),
12523           " "));
12524 
12525 
12526       System.out.flush();
12527       output = new String(baos.toByteArray());
12528 
12529       System.setOut(systemOut);
12530 
12531       outputLines = GrouperClientUtils.splitTrim(output, "\n");
12532 
12533       outputLine = outputLines[0];
12534 
12535       matcher = pattern.matcher(outputLines[0]);
12536 
12537       assertTrue(outputLine, matcher.matches());
12538       assertEquals(outputLine, "0", matcher.group(1));
12539       assertEquals(outputLine, "stem", matcher.group(2));
12540       assertEquals(outputLine, "test:stemTestAttrAssign", matcher.group(3));
12541       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
12542       assertEquals(outputLine, "assign", matcher.group(5));
12543       assertEquals(outputLine, "none", matcher.group(6));
12544       assertEquals(outputLine, "T", matcher.group(7));
12545       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
12546 
12547       assertTrue(GrouperClientWs.mostRecentRequest,
12548           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
12549       assertTrue(GrouperClientWs.mostRecentRequest,
12550           !GrouperClientWs.mostRecentRequest.contains("actions"));
12551       assertTrue(GrouperClientWs.mostRecentRequest,
12552           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
12553       assertTrue(GrouperClientWs.mostRecentRequest,
12554           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
12555       assertTrue(GrouperClientWs.mostRecentRequest,
12556           !GrouperClientWs.mostRecentRequest.contains("enabled"));
12557       assertTrue(GrouperClientWs.mostRecentRequest,
12558           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
12559       assertTrue(GrouperClientWs.mostRecentRequest,
12560           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
12561       assertTrue(GrouperClientWs.mostRecentRequest,
12562           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
12563       assertTrue(GrouperClientWs.mostRecentRequest,
12564           !GrouperClientWs.mostRecentRequest.contains("params"));
12565       assertTrue(GrouperClientWs.mostRecentRequest,
12566           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
12567       assertTrue(GrouperClientWs.mostRecentRequest,
12568           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
12569       assertTrue(GrouperClientWs.mostRecentRequest,
12570           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
12571       assertTrue(GrouperClientWs.mostRecentRequest,
12572           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
12573       assertTrue(GrouperClientWs.mostRecentRequest,
12574           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
12575       assertTrue(GrouperClientWs.mostRecentRequest,
12576           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
12577       assertTrue(GrouperClientWs.mostRecentRequest,
12578           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
12579       assertTrue(GrouperClientWs.mostRecentRequest,
12580           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
12581       assertTrue(GrouperClientWs.mostRecentRequest,
12582           GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
12583       assertTrue(GrouperClientWs.mostRecentRequest,
12584           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
12585 
12586 
12587 
12588 
12589     } finally {
12590       System.setOut(systemOut);
12591     }
12592 
12593   }
12594 
12595   /**
12596    * @throws Exception
12597    */
12598   public void testGetAttributeAssignsMember() throws Exception {
12599 
12600     AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
12601 
12602     final AttributeDef attributeDef = attributeDefName.getAttributeDef();
12603 
12604     attributeDef.setAssignToGroup(false);
12605     attributeDef.setAssignToMember(true);
12606     attributeDef.store();
12607 
12608     GrouperSession grouperSession = GrouperSession.startRootSession();
12609 
12610     Member member = MemberFinder.findBySubject(grouperSession, SubjectTestHelper.SUBJ0, true);
12611 
12612     AttributeAssignResult attributeAssignResult = member.getAttributeDelegate().assignAttribute(attributeDefName);
12613     AttributeAssign attributeAssign = attributeAssignResult.getAttributeAssign();
12614 
12615 
12616     PrintStream systemOut = System.out;
12617 
12618     ByteArrayOutputStream baos = new ByteArrayOutputStream();
12619     System.setOut(new PrintStream(baos));
12620 
12621     try {
12622 
12623       GrouperClient.main(GrouperClientUtils.splitTrim(
12624           "--operation=getAttributeAssignmentsWs --attributeAssignType=member --attributeDefNames=test:testAttributeAssignDefNameDef",
12625           " "));
12626       System.out.flush();
12627       String output = new String(baos.toByteArray());
12628 
12629       System.setOut(systemOut);
12630 
12631       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
12632 
12633       // match: Index: 0: attributeAssignType: member, owner: test:stemTestAttrAssign, attributeDefNameName test:testAttributeAssignDefName, action: assign, values: none, enable: T, id: a9c83eeb78c04ae5befcea36272d318c
12634       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
12635       Pattern pattern = Pattern
12636           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
12637       String outputLine = outputLines[0];
12638 
12639       Matcher matcher = pattern.matcher(outputLines[0]);
12640 
12641       assertTrue(outputLine, matcher.matches());
12642       assertEquals(outputLine, "0", matcher.group(1));
12643       assertEquals(outputLine, "member", matcher.group(2));
12644       assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(3));
12645       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
12646       assertEquals(outputLine, "assign", matcher.group(5));
12647       assertEquals(outputLine, "none", matcher.group(6));
12648       assertEquals(outputLine, "T", matcher.group(7));
12649       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
12650 
12651       assertTrue(GrouperClientWs.mostRecentRequest,
12652           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
12653       assertTrue(GrouperClientWs.mostRecentRequest,
12654           !GrouperClientWs.mostRecentRequest.contains("actions"));
12655       assertTrue(GrouperClientWs.mostRecentRequest,
12656           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
12657       assertTrue(GrouperClientWs.mostRecentRequest,
12658           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
12659       assertTrue(GrouperClientWs.mostRecentRequest,
12660           !GrouperClientWs.mostRecentRequest.contains("enabled"));
12661       assertTrue(GrouperClientWs.mostRecentRequest,
12662           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
12663       assertTrue(GrouperClientWs.mostRecentRequest,
12664           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
12665       assertTrue(GrouperClientWs.mostRecentRequest,
12666           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
12667       assertTrue(GrouperClientWs.mostRecentRequest,
12668           !GrouperClientWs.mostRecentRequest.contains("params"));
12669       assertTrue(GrouperClientWs.mostRecentRequest,
12670           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
12671       assertTrue(GrouperClientWs.mostRecentRequest,
12672           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
12673       assertTrue(GrouperClientWs.mostRecentRequest,
12674           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
12675       assertTrue(GrouperClientWs.mostRecentRequest,
12676           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
12677       assertTrue(GrouperClientWs.mostRecentRequest,
12678           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
12679       assertTrue(GrouperClientWs.mostRecentRequest,
12680           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
12681       assertTrue(GrouperClientWs.mostRecentRequest,
12682           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
12683       assertTrue(GrouperClientWs.mostRecentRequest,
12684           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
12685       assertTrue(GrouperClientWs.mostRecentRequest,
12686           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
12687       assertTrue(GrouperClientWs.mostRecentRequest,
12688           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
12689 
12690       // ######################################################
12691       // Try wsOwnerMemberUuids
12692 
12693       baos = new ByteArrayOutputStream();
12694       System.setOut(new PrintStream(baos));
12695 
12696       GrouperClient.main(GrouperClientUtils.splitTrim(
12697           "--operation=getAttributeAssignmentsWs --attributeAssignType=member --owner0SubjectId=" + member.getSubjectId(),
12698           " "));
12699 
12700 
12701       System.out.flush();
12702       output = new String(baos.toByteArray());
12703 
12704       System.setOut(systemOut);
12705 
12706       outputLines = GrouperClientUtils.splitTrim(output, "\n");
12707 
12708       outputLine = outputLines[0];
12709 
12710       matcher = pattern.matcher(outputLine);
12711 
12712       assertTrue(outputLine, matcher.matches());
12713       assertEquals(outputLine, "0", matcher.group(1));
12714       assertEquals(outputLine, "member", matcher.group(2));
12715       assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(3));
12716       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
12717       assertEquals(outputLine, "assign", matcher.group(5));
12718       assertEquals(outputLine, "none", matcher.group(6));
12719       assertEquals(outputLine, "T", matcher.group(7));
12720       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
12721 
12722       assertTrue(GrouperClientWs.mostRecentRequest,
12723           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
12724       assertTrue(GrouperClientWs.mostRecentRequest,
12725           !GrouperClientWs.mostRecentRequest.contains("actions"));
12726       assertTrue(GrouperClientWs.mostRecentRequest,
12727           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
12728       assertTrue(GrouperClientWs.mostRecentRequest,
12729           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
12730       assertTrue(GrouperClientWs.mostRecentRequest,
12731           !GrouperClientWs.mostRecentRequest.contains("enabled"));
12732       assertTrue(GrouperClientWs.mostRecentRequest,
12733           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
12734       assertTrue(GrouperClientWs.mostRecentRequest,
12735           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
12736       assertTrue(GrouperClientWs.mostRecentRequest,
12737           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
12738       assertTrue(GrouperClientWs.mostRecentRequest,
12739           !GrouperClientWs.mostRecentRequest.contains("params"));
12740       assertTrue(GrouperClientWs.mostRecentRequest,
12741           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
12742       assertTrue(GrouperClientWs.mostRecentRequest,
12743           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
12744       assertTrue(GrouperClientWs.mostRecentRequest,
12745           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
12746       assertTrue(GrouperClientWs.mostRecentRequest,
12747           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
12748       assertTrue(GrouperClientWs.mostRecentRequest,
12749           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
12750       assertTrue(GrouperClientWs.mostRecentRequest,
12751           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
12752       assertTrue(GrouperClientWs.mostRecentRequest,
12753           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
12754       assertTrue(GrouperClientWs.mostRecentRequest,
12755           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
12756       assertTrue(GrouperClientWs.mostRecentRequest,
12757           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
12758       assertTrue(GrouperClientWs.mostRecentRequest,
12759           GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
12760 
12761 
12762       // ######################################################
12763       // Try wsOwnerStemNames
12764 
12765       baos = new ByteArrayOutputStream();
12766       System.setOut(new PrintStream(baos));
12767 
12768       GrouperClient.main(GrouperClientUtils.splitTrim(
12769           "--operation=getAttributeAssignmentsWs --attributeAssignType=member --owner0SubjectIdentifier=id.test.subject.0",
12770           " "));
12771 
12772 
12773       System.out.flush();
12774       output = new String(baos.toByteArray());
12775 
12776       System.setOut(systemOut);
12777 
12778       outputLines = GrouperClientUtils.splitTrim(output, "\n");
12779 
12780       outputLine = outputLines[0];
12781 
12782       matcher = pattern.matcher(outputLines[0]);
12783 
12784       assertTrue(outputLine, matcher.matches());
12785       assertEquals(outputLine, "0", matcher.group(1));
12786       assertEquals(outputLine, "member", matcher.group(2));
12787       assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(3));
12788       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
12789       assertEquals(outputLine, "assign", matcher.group(5));
12790       assertEquals(outputLine, "none", matcher.group(6));
12791       assertEquals(outputLine, "T", matcher.group(7));
12792       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
12793 
12794       assertTrue(GrouperClientWs.mostRecentRequest,
12795           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
12796       assertTrue(GrouperClientWs.mostRecentRequest,
12797           !GrouperClientWs.mostRecentRequest.contains("actions"));
12798       assertTrue(GrouperClientWs.mostRecentRequest,
12799           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
12800       assertTrue(GrouperClientWs.mostRecentRequest,
12801           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
12802       assertTrue(GrouperClientWs.mostRecentRequest,
12803           !GrouperClientWs.mostRecentRequest.contains("enabled"));
12804       assertTrue(GrouperClientWs.mostRecentRequest,
12805           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
12806       assertTrue(GrouperClientWs.mostRecentRequest,
12807           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
12808       assertTrue(GrouperClientWs.mostRecentRequest,
12809           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
12810       assertTrue(GrouperClientWs.mostRecentRequest,
12811           !GrouperClientWs.mostRecentRequest.contains("params"));
12812       assertTrue(GrouperClientWs.mostRecentRequest,
12813           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
12814       assertTrue(GrouperClientWs.mostRecentRequest,
12815           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
12816       assertTrue(GrouperClientWs.mostRecentRequest,
12817           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
12818       assertTrue(GrouperClientWs.mostRecentRequest,
12819           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
12820       assertTrue(GrouperClientWs.mostRecentRequest,
12821           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
12822       assertTrue(GrouperClientWs.mostRecentRequest,
12823           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
12824       assertTrue(GrouperClientWs.mostRecentRequest,
12825           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
12826       assertTrue(GrouperClientWs.mostRecentRequest,
12827           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
12828       assertTrue(GrouperClientWs.mostRecentRequest,
12829           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
12830       assertTrue(GrouperClientWs.mostRecentRequest,
12831           GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
12832 
12833 
12834 
12835 
12836     } finally {
12837       System.setOut(systemOut);
12838     }
12839 
12840   }
12841 
12842   /**
12843    * @throws Exception
12844    */
12845   public void testGetAttributeAssignsMembership() throws Exception {
12846 
12847     AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
12848 
12849     final AttributeDef attributeDef = attributeDefName.getAttributeDef();
12850 
12851     attributeDef.setAssignToGroup(false);
12852     attributeDef.setAssignToImmMembership(true);
12853     attributeDef.store();
12854 
12855     Group group1 = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
12856       .assignGroupNameToEdit("test:membershipTestAttrAssign").assignName("test:membershipTestAttrAssign").assignCreateParentStemsIfNotExist(true)
12857       .assignDescription("description").save();
12858 
12859     group1.addMember(SubjectTestHelper.SUBJ0);
12860 
12861     Membership membership = group1.getMemberships(FieldFinder.find("members", true)).iterator().next();
12862 
12863 
12864     AttributeAssignResult attributeAssignResult = membership.getAttributeDelegate().assignAttribute(attributeDefName);
12865     AttributeAssign attributeAssign = attributeAssignResult.getAttributeAssign();
12866 
12867 
12868     PrintStream systemOut = System.out;
12869 
12870     ByteArrayOutputStream baos = new ByteArrayOutputStream();
12871     System.setOut(new PrintStream(baos));
12872 
12873     try {
12874 
12875       GrouperClient.main(GrouperClientUtils.splitTrim(
12876           "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem --attributeDefNames=test:testAttributeAssignDefNameDef",
12877           " "));
12878       System.out.flush();
12879       String output = new String(baos.toByteArray());
12880 
12881       System.setOut(systemOut);
12882 
12883       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
12884 
12885       // match: Index: 0: attributeAssignType: member, owner: test:stemTestAttrAssign, attributeDefNameName test:testAttributeAssignDefName, action: assign, values: none, enable: T, id: a9c83eeb78c04ae5befcea36272d318c
12886       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
12887       Pattern pattern = Pattern
12888           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
12889       String outputLine = outputLines[0];
12890 
12891       Matcher matcher = pattern.matcher(outputLines[0]);
12892 
12893       assertTrue(outputLine, matcher.matches());
12894       assertEquals(outputLine, "0", matcher.group(1));
12895       assertEquals(outputLine, "imm_mem", matcher.group(2));
12896       assertEquals(outputLine, membership.getImmediateMembershipId(), matcher.group(3));
12897       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
12898       assertEquals(outputLine, "assign", matcher.group(5));
12899       assertEquals(outputLine, "none", matcher.group(6));
12900       assertEquals(outputLine, "T", matcher.group(7));
12901       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
12902 
12903       assertTrue(GrouperClientWs.mostRecentRequest,
12904           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
12905       assertTrue(GrouperClientWs.mostRecentRequest,
12906           !GrouperClientWs.mostRecentRequest.contains("actions"));
12907       assertTrue(GrouperClientWs.mostRecentRequest,
12908           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
12909       assertTrue(GrouperClientWs.mostRecentRequest,
12910           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
12911       assertTrue(GrouperClientWs.mostRecentRequest,
12912           !GrouperClientWs.mostRecentRequest.contains("enabled"));
12913       assertTrue(GrouperClientWs.mostRecentRequest,
12914           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
12915       assertTrue(GrouperClientWs.mostRecentRequest,
12916           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
12917       assertTrue(GrouperClientWs.mostRecentRequest,
12918           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
12919       assertTrue(GrouperClientWs.mostRecentRequest,
12920           !GrouperClientWs.mostRecentRequest.contains("params"));
12921       assertTrue(GrouperClientWs.mostRecentRequest,
12922           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
12923       assertTrue(GrouperClientWs.mostRecentRequest,
12924           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
12925       assertTrue(GrouperClientWs.mostRecentRequest,
12926           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
12927       assertTrue(GrouperClientWs.mostRecentRequest,
12928           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
12929       assertTrue(GrouperClientWs.mostRecentRequest,
12930           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
12931       assertTrue(GrouperClientWs.mostRecentRequest,
12932           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
12933       assertTrue(GrouperClientWs.mostRecentRequest,
12934           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
12935       assertTrue(GrouperClientWs.mostRecentRequest,
12936           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
12937       assertTrue(GrouperClientWs.mostRecentRequest,
12938           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
12939       assertTrue(GrouperClientWs.mostRecentRequest,
12940           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
12941 
12942       // ######################################################
12943       // Try wsOwnerMemberUuids
12944 
12945       baos = new ByteArrayOutputStream();
12946       System.setOut(new PrintStream(baos));
12947 
12948       GrouperClient.main(GrouperClientUtils.splitTrim(
12949           "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem --ownerMembershipUuids=" + membership.getUuid(),
12950           " "));
12951 
12952 
12953       System.out.flush();
12954       output = new String(baos.toByteArray());
12955 
12956       System.setOut(systemOut);
12957 
12958       outputLines = GrouperClientUtils.splitTrim(output, "\n");
12959 
12960       outputLine = outputLines[0];
12961 
12962       matcher = pattern.matcher(outputLine);
12963 
12964       assertTrue(outputLine, matcher.matches());
12965       assertEquals(outputLine, "0", matcher.group(1));
12966       assertEquals(outputLine, "imm_mem", matcher.group(2));
12967       assertEquals(outputLine, membership.getImmediateMembershipId(), matcher.group(3));
12968       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
12969       assertEquals(outputLine, "assign", matcher.group(5));
12970       assertEquals(outputLine, "none", matcher.group(6));
12971       assertEquals(outputLine, "T", matcher.group(7));
12972       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
12973 
12974       assertTrue(GrouperClientWs.mostRecentRequest,
12975           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
12976       assertTrue(GrouperClientWs.mostRecentRequest,
12977           !GrouperClientWs.mostRecentRequest.contains("actions"));
12978       assertTrue(GrouperClientWs.mostRecentRequest,
12979           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
12980       assertTrue(GrouperClientWs.mostRecentRequest,
12981           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
12982       assertTrue(GrouperClientWs.mostRecentRequest,
12983           !GrouperClientWs.mostRecentRequest.contains("enabled"));
12984       assertTrue(GrouperClientWs.mostRecentRequest,
12985           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
12986       assertTrue(GrouperClientWs.mostRecentRequest,
12987           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
12988       assertTrue(GrouperClientWs.mostRecentRequest,
12989           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
12990       assertTrue(GrouperClientWs.mostRecentRequest,
12991           !GrouperClientWs.mostRecentRequest.contains("params"));
12992       assertTrue(GrouperClientWs.mostRecentRequest,
12993           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
12994       assertTrue(GrouperClientWs.mostRecentRequest,
12995           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
12996       assertTrue(GrouperClientWs.mostRecentRequest,
12997           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
12998       assertTrue(GrouperClientWs.mostRecentRequest,
12999           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
13000       assertTrue(GrouperClientWs.mostRecentRequest,
13001           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
13002       assertTrue(GrouperClientWs.mostRecentRequest,
13003           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
13004       assertTrue(GrouperClientWs.mostRecentRequest,
13005           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
13006       assertTrue(GrouperClientWs.mostRecentRequest,
13007           GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
13008       assertTrue(GrouperClientWs.mostRecentRequest,
13009           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
13010       assertTrue(GrouperClientWs.mostRecentRequest,
13011           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
13012 
13013 
13014 
13015     } finally {
13016       System.setOut(systemOut);
13017     }
13018 
13019   }
13020 
13021   /**
13022    * @throws Exception
13023    */
13024   public void testGetAttributeAssignsAnyMembership() throws Exception {
13025 
13026     GrouperSession grouperSession = GrouperSession.startRootSession();
13027 
13028     AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
13029 
13030     final AttributeDef attributeDef = attributeDefName.getAttributeDef();
13031 
13032     attributeDef.setAssignToGroup(false);
13033     attributeDef.setAssignToEffMembership(true);
13034     attributeDef.store();
13035 
13036     Group group1 = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
13037       .assignGroupNameToEdit("test:anyMembershipTestAttrAssign").assignName("test:anyMembershipTestAttrAssign").assignCreateParentStemsIfNotExist(true)
13038       .assignDescription("description").save();
13039 
13040     Group group2 = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
13041       .assignGroupNameToEdit("test:anyMembershipTestAttrAssign2").assignName("test:anyMembershipTestAttrAssign2").assignCreateParentStemsIfNotExist(true)
13042       .assignDescription("description").save();
13043 
13044     //add one group to another to make effective membership and add attribute to that membership
13045     group1.addMember(group2.toSubject());
13046     group2.addMember(SubjectTestHelper.SUBJ0);
13047 
13048     Member member = MemberFinder.findBySubject(grouperSession, SubjectTestHelper.SUBJ0, false);
13049 
13050     Membership membership = (Membership)MembershipFinder.findMemberships(GrouperUtil.toSet(group1.getId()),
13051         GrouperUtil.toSet(member.getUuid()), null, null, FieldFinder.find("members", true), null, null, null, null, null).iterator().next()[0];
13052 
13053     AttributeAssignResult attributeAssignResult = membership.getAttributeDelegateEffMship().assignAttribute(attributeDefName);
13054     AttributeAssign attributeAssign = attributeAssignResult.getAttributeAssign();
13055 
13056 
13057     PrintStream systemOut = System.out;
13058 
13059     ByteArrayOutputStream baos = new ByteArrayOutputStream();
13060     System.setOut(new PrintStream(baos));
13061 
13062     try {
13063 
13064       GrouperClient.main(GrouperClientUtils.splitTrim(
13065           "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem --attributeDefNames=test:testAttributeAssignDefNameDef",
13066           " "));
13067       System.out.flush();
13068       String output = new String(baos.toByteArray());
13069 
13070       System.setOut(systemOut);
13071 
13072       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
13073 
13074       // match: Index: 0: attributeAssignType: any_mem, owner: test:stemTestAttrAssign, attributeDefNameName test:testAttributeAssignDefName, action: assign, values: none, enable: T, id: a9c83eeb78c04ae5befcea36272d318c
13075       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
13076       Pattern pattern = Pattern
13077           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
13078       String outputLine = outputLines[0];
13079 
13080       Matcher matcher = pattern.matcher(outputLines[0]);
13081 
13082       assertTrue(outputLine, matcher.matches());
13083       assertEquals(outputLine, "0", matcher.group(1));
13084       assertEquals(outputLine, "any_mem", matcher.group(2));
13085       assertEquals(outputLine, "test:anyMembershipTestAttrAssign - jdbc - test.subject.0", matcher.group(3));
13086       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
13087       assertEquals(outputLine, "assign", matcher.group(5));
13088       assertEquals(outputLine, "none", matcher.group(6));
13089       assertEquals(outputLine, "T", matcher.group(7));
13090       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
13091 
13092       assertTrue(GrouperClientWs.mostRecentRequest,
13093           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
13094       assertTrue(GrouperClientWs.mostRecentRequest,
13095           !GrouperClientWs.mostRecentRequest.contains("actions"));
13096       assertTrue(GrouperClientWs.mostRecentRequest,
13097           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
13098       assertTrue(GrouperClientWs.mostRecentRequest,
13099           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
13100       assertTrue(GrouperClientWs.mostRecentRequest,
13101           !GrouperClientWs.mostRecentRequest.contains("enabled"));
13102       assertTrue(GrouperClientWs.mostRecentRequest,
13103           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
13104       assertTrue(GrouperClientWs.mostRecentRequest,
13105           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
13106       assertTrue(GrouperClientWs.mostRecentRequest,
13107           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
13108       assertTrue(GrouperClientWs.mostRecentRequest,
13109           !GrouperClientWs.mostRecentRequest.contains("params"));
13110       assertTrue(GrouperClientWs.mostRecentRequest,
13111           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
13112       assertTrue(GrouperClientWs.mostRecentRequest,
13113           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
13114       assertTrue(GrouperClientWs.mostRecentRequest,
13115           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
13116       assertTrue(GrouperClientWs.mostRecentRequest,
13117           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
13118       assertTrue(GrouperClientWs.mostRecentRequest,
13119           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
13120       assertTrue(GrouperClientWs.mostRecentRequest,
13121           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
13122       assertTrue(GrouperClientWs.mostRecentRequest,
13123           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
13124       assertTrue(GrouperClientWs.mostRecentRequest,
13125           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
13126       assertTrue(GrouperClientWs.mostRecentRequest,
13127           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
13128       assertTrue(GrouperClientWs.mostRecentRequest,
13129           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
13130 
13131       // ######################################################
13132       // Try wsOwnerMemberAnyLookup
13133 
13134       baos = new ByteArrayOutputStream();
13135       System.setOut(new PrintStream(baos));
13136 
13137       GrouperClient.main(GrouperClientUtils.splitTrim(
13138           "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem --ownerMembershipAny0SubjectId=" + member.getSubjectId()
13139           + " --ownerMembershipAny0GroupName=" + group1.getName(),
13140           " "));
13141 
13142 
13143       System.out.flush();
13144       output = new String(baos.toByteArray());
13145 
13146       System.setOut(systemOut);
13147 
13148       outputLines = GrouperClientUtils.splitTrim(output, "\n");
13149 
13150       outputLine = outputLines[0];
13151 
13152       matcher = pattern.matcher(outputLine);
13153 
13154       assertTrue(outputLine, matcher.matches());
13155       assertEquals(outputLine, "0", matcher.group(1));
13156       assertEquals(outputLine, "any_mem", matcher.group(2));
13157       assertEquals(outputLine, "test:anyMembershipTestAttrAssign - jdbc - test.subject.0", matcher.group(3));
13158       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
13159       assertEquals(outputLine, "assign", matcher.group(5));
13160       assertEquals(outputLine, "none", matcher.group(6));
13161       assertEquals(outputLine, "T", matcher.group(7));
13162       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
13163 
13164       assertTrue(GrouperClientWs.mostRecentRequest,
13165           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
13166       assertTrue(GrouperClientWs.mostRecentRequest,
13167           !GrouperClientWs.mostRecentRequest.contains("actions"));
13168       assertTrue(GrouperClientWs.mostRecentRequest,
13169           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
13170       assertTrue(GrouperClientWs.mostRecentRequest,
13171           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
13172       assertTrue(GrouperClientWs.mostRecentRequest,
13173           !GrouperClientWs.mostRecentRequest.contains("enabled"));
13174       assertTrue(GrouperClientWs.mostRecentRequest,
13175           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
13176       assertTrue(GrouperClientWs.mostRecentRequest,
13177           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
13178       assertTrue(GrouperClientWs.mostRecentRequest,
13179           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
13180       assertTrue(GrouperClientWs.mostRecentRequest,
13181           !GrouperClientWs.mostRecentRequest.contains("params"));
13182       assertTrue(GrouperClientWs.mostRecentRequest,
13183           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
13184       assertTrue(GrouperClientWs.mostRecentRequest,
13185           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
13186       assertTrue(GrouperClientWs.mostRecentRequest,
13187           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
13188       assertTrue(GrouperClientWs.mostRecentRequest,
13189           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
13190       assertTrue(GrouperClientWs.mostRecentRequest,
13191           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
13192       assertTrue(GrouperClientWs.mostRecentRequest,
13193           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
13194       assertTrue(GrouperClientWs.mostRecentRequest,
13195           GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
13196       assertTrue(GrouperClientWs.mostRecentRequest,
13197           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
13198       assertTrue(GrouperClientWs.mostRecentRequest,
13199           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
13200       assertTrue(GrouperClientWs.mostRecentRequest,
13201           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
13202 
13203 
13204       // ######################################################
13205       // Try wsOwnerMemberAnyLookup
13206 
13207       baos = new ByteArrayOutputStream();
13208       System.setOut(new PrintStream(baos));
13209 
13210       GrouperClient.main(GrouperClientUtils.splitTrim(
13211           "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem --ownerMembershipAny0SubjectId=" + member.getSubjectId()
13212           + " --ownerMembershipAny0GroupIdIndex=" + group1.getIdIndex(),
13213           " "));
13214 
13215 
13216       System.out.flush();
13217       output = new String(baos.toByteArray());
13218 
13219       System.setOut(systemOut);
13220 
13221       outputLines = GrouperClientUtils.splitTrim(output, "\n");
13222 
13223       outputLine = outputLines[0];
13224 
13225       matcher = pattern.matcher(outputLine);
13226 
13227       assertTrue(outputLine, matcher.matches());
13228       assertEquals(outputLine, "0", matcher.group(1));
13229       assertEquals(outputLine, "any_mem", matcher.group(2));
13230       assertEquals(outputLine, "test:anyMembershipTestAttrAssign - jdbc - test.subject.0", matcher.group(3));
13231       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
13232       assertEquals(outputLine, "assign", matcher.group(5));
13233       assertEquals(outputLine, "none", matcher.group(6));
13234       assertEquals(outputLine, "T", matcher.group(7));
13235       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
13236 
13237       assertTrue(GrouperClientWs.mostRecentRequest,
13238           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
13239       assertTrue(GrouperClientWs.mostRecentRequest,
13240           !GrouperClientWs.mostRecentRequest.contains("actions"));
13241       assertTrue(GrouperClientWs.mostRecentRequest,
13242           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
13243       assertTrue(GrouperClientWs.mostRecentRequest,
13244           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
13245       assertTrue(GrouperClientWs.mostRecentRequest,
13246           !GrouperClientWs.mostRecentRequest.contains("enabled"));
13247       assertTrue(GrouperClientWs.mostRecentRequest,
13248           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
13249       assertTrue(GrouperClientWs.mostRecentRequest,
13250           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
13251       assertTrue(GrouperClientWs.mostRecentRequest,
13252           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
13253       assertTrue(GrouperClientWs.mostRecentRequest,
13254           !GrouperClientWs.mostRecentRequest.contains("params"));
13255       assertTrue(GrouperClientWs.mostRecentRequest,
13256           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
13257       assertTrue(GrouperClientWs.mostRecentRequest,
13258           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
13259       assertTrue(GrouperClientWs.mostRecentRequest,
13260           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
13261       assertTrue(GrouperClientWs.mostRecentRequest,
13262           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
13263       assertTrue(GrouperClientWs.mostRecentRequest,
13264           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
13265       assertTrue(GrouperClientWs.mostRecentRequest,
13266           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
13267       assertTrue(GrouperClientWs.mostRecentRequest,
13268           GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
13269       assertTrue(GrouperClientWs.mostRecentRequest,
13270           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
13271       assertTrue(GrouperClientWs.mostRecentRequest,
13272           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
13273       assertTrue(GrouperClientWs.mostRecentRequest,
13274           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
13275 
13276 
13277 
13278     } finally {
13279       System.setOut(systemOut);
13280     }
13281 
13282   }
13283 
13284   /**
13285    * @throws Exception
13286    */
13287   public void testGetAttributeAssignsAttributeDef() throws Exception {
13288 
13289     AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb(
13290         "test", "testAttributeAssignDefName");
13291 
13292     final AttributeDef attributeDef = attributeDefName.getAttributeDef();
13293 
13294     attributeDef.setAssignToGroup(false);
13295     attributeDef.setAssignToAttributeDef(true);
13296     attributeDef.store();
13297 
13298     AttributeDef attributeDefAssignTo = AttributeDefTest.exampleAttributeDefDb("test",
13299         "testAttributeDefAssignTo");
13300 
13301     AttributeAssignResult attributeAssignResult = attributeDefAssignTo
13302         .getAttributeDelegate().assignAttribute(attributeDefName);
13303     AttributeAssign attributeAssign = attributeAssignResult.getAttributeAssign();
13304 
13305     PrintStream systemOut = System.out;
13306 
13307     ByteArrayOutputStream baos = new ByteArrayOutputStream();
13308     System.setOut(new PrintStream(baos));
13309 
13310     try {
13311 
13312       GrouperClient
13313           .main(GrouperClientUtils
13314               .splitTrim(
13315                   "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def --attributeDefNames=test:testAttributeAssignDefNameDef",
13316                   " "));
13317       System.out.flush();
13318       String output = new String(baos.toByteArray());
13319 
13320       System.setOut(systemOut);
13321 
13322       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
13323 
13324       // match: Index: 0: attributeAssignType: stem, owner: test:stemTestAttrAssign, attributeDefNameName test:testAttributeAssignDefName, action: assign, values: none, enable: T, id: a9c83eeb78c04ae5befcea36272d318c
13325       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
13326       Pattern pattern = Pattern
13327           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
13328       String outputLine = outputLines[0];
13329 
13330       Matcher matcher = pattern.matcher(outputLines[0]);
13331 
13332       assertTrue(outputLine, matcher.matches());
13333       assertEquals(outputLine, "0", matcher.group(1));
13334       assertEquals(outputLine, "attr_def", matcher.group(2));
13335       assertEquals(outputLine, "test:testAttributeDefAssignTo", matcher.group(3));
13336       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
13337       assertEquals(outputLine, "assign", matcher.group(5));
13338       assertEquals(outputLine, "none", matcher.group(6));
13339       assertEquals(outputLine, "T", matcher.group(7));
13340       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
13341 
13342       assertTrue(GrouperClientWs.mostRecentRequest,
13343           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
13344       assertTrue(GrouperClientWs.mostRecentRequest,
13345           !GrouperClientWs.mostRecentRequest.contains("actions"));
13346       assertTrue(GrouperClientWs.mostRecentRequest,
13347           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
13348       assertTrue(GrouperClientWs.mostRecentRequest,
13349           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
13350       assertTrue(GrouperClientWs.mostRecentRequest,
13351           !GrouperClientWs.mostRecentRequest.contains("enabled"));
13352       assertTrue(GrouperClientWs.mostRecentRequest,
13353           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
13354       assertTrue(GrouperClientWs.mostRecentRequest,
13355           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
13356       assertTrue(GrouperClientWs.mostRecentRequest,
13357           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
13358       assertTrue(GrouperClientWs.mostRecentRequest,
13359           !GrouperClientWs.mostRecentRequest.contains("params"));
13360       assertTrue(GrouperClientWs.mostRecentRequest,
13361           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
13362       assertTrue(GrouperClientWs.mostRecentRequest,
13363           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
13364       assertTrue(GrouperClientWs.mostRecentRequest,
13365           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups")
13366               && GrouperClientWs.mostRecentRequest.contains("<name>"));
13367       assertTrue(GrouperClientWs.mostRecentRequest,
13368           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
13369       assertTrue(GrouperClientWs.mostRecentRequest,
13370           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
13371       assertTrue(GrouperClientWs.mostRecentRequest,
13372           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
13373       assertTrue(GrouperClientWs.mostRecentRequest,
13374           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
13375       assertTrue(GrouperClientWs.mostRecentRequest,
13376           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
13377       assertTrue(GrouperClientWs.mostRecentRequest,
13378           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
13379       assertTrue(GrouperClientWs.mostRecentRequest,
13380           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
13381 
13382       // ######################################################
13383       // Try wsAttrDefUuids
13384 
13385       baos = new ByteArrayOutputStream();
13386       System.setOut(new PrintStream(baos));
13387 
13388       GrouperClient
13389           .main(GrouperClientUtils
13390               .splitTrim(
13391                   "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def --ownerAttributeDefUuids="
13392                       + attributeDefAssignTo.getUuid(),
13393                   " "));
13394 
13395       System.out.flush();
13396       output = new String(baos.toByteArray());
13397 
13398       System.setOut(systemOut);
13399 
13400       outputLines = GrouperClientUtils.splitTrim(output, "\n");
13401 
13402       outputLine = outputLines[0];
13403 
13404       matcher = pattern.matcher(outputLine);
13405 
13406       assertTrue(outputLine, matcher.matches());
13407       assertEquals(outputLine, "0", matcher.group(1));
13408       assertEquals(outputLine, "attr_def", matcher.group(2));
13409       assertEquals(outputLine, "test:testAttributeDefAssignTo", matcher.group(3));
13410       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
13411       assertEquals(outputLine, "assign", matcher.group(5));
13412       assertEquals(outputLine, "none", matcher.group(6));
13413       assertEquals(outputLine, "T", matcher.group(7));
13414       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
13415 
13416       assertTrue(GrouperClientWs.mostRecentRequest,
13417           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
13418       assertTrue(GrouperClientWs.mostRecentRequest,
13419           !GrouperClientWs.mostRecentRequest.contains("actions"));
13420       assertTrue(GrouperClientWs.mostRecentRequest,
13421           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
13422       assertTrue(GrouperClientWs.mostRecentRequest,
13423           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
13424       assertTrue(GrouperClientWs.mostRecentRequest,
13425           !GrouperClientWs.mostRecentRequest.contains("enabled"));
13426       assertTrue(GrouperClientWs.mostRecentRequest,
13427           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
13428       assertTrue(GrouperClientWs.mostRecentRequest,
13429           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
13430       assertTrue(GrouperClientWs.mostRecentRequest,
13431           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
13432       assertTrue(GrouperClientWs.mostRecentRequest,
13433           !GrouperClientWs.mostRecentRequest.contains("params"));
13434       assertTrue(GrouperClientWs.mostRecentRequest,
13435           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
13436       assertTrue(GrouperClientWs.mostRecentRequest,
13437           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
13438       assertTrue(GrouperClientWs.mostRecentRequest,
13439           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
13440       assertTrue(GrouperClientWs.mostRecentRequest,
13441           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
13442       assertTrue(GrouperClientWs.mostRecentRequest,
13443           GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
13444       assertTrue(GrouperClientWs.mostRecentRequest,
13445           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
13446       assertTrue(GrouperClientWs.mostRecentRequest,
13447           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
13448       assertTrue(GrouperClientWs.mostRecentRequest,
13449           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
13450       assertTrue(GrouperClientWs.mostRecentRequest,
13451           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
13452       assertTrue(GrouperClientWs.mostRecentRequest,
13453           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
13454 
13455     } finally {
13456       System.setOut(systemOut);
13457     }
13458 
13459   }
13460 
13461   /**
13462    * @throws Exception
13463    */
13464   public void testAssignAttributesGroup() throws Exception {
13465 
13466     AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
13467 
13468     final AttributeDef attributeDef = attributeDefName.getAttributeDef();
13469 
13470     attributeDef.setValueType(AttributeDefValueType.integer);
13471     attributeDef.setMultiValued(true);
13472     attributeDef.store();
13473 
13474     Group group = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
13475       .assignGroupNameToEdit("test:groupTestAttrAssign").assignName("test:groupTestAttrAssign").assignCreateParentStemsIfNotExist(true)
13476       .assignDescription("description").save();
13477 
13478     //test subject 0 can view and read
13479     group.grantPriv(SubjectTestHelper.SUBJ0, AccessPrivilege.VIEW);
13480     attributeDef.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ0, AttributeDefPrivilege.ATTR_READ, false);
13481 
13482     AttributeAssign attributeAssign = null;
13483     //    AttributeAssignResult attributeAssignResult = group.getAttributeDelegate().assignAttribute(attributeDefName);
13484     //     = attributeAssignResult.getAttributeAssign();
13485 
13486     PrintStream systemOut = System.out;
13487 
13488     ByteArrayOutputStream baos = new ByteArrayOutputStream();
13489     System.setOut(new PrintStream(baos));
13490 
13491     try {
13492 
13493       GrouperClient.main(GrouperClientUtils.splitTrim(
13494           "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=assign_attr " +
13495           "--attributeDefNameNames=test:testAttributeAssignDefName --ownerGroupNames=test:groupTestAttrAssign",
13496           " "));
13497 
13498       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
13499 
13500       System.out.flush();
13501       String output = new String(baos.toByteArray());
13502 
13503       System.setOut(systemOut);
13504 
13505       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
13506 
13507       // match: Index: 0: attributeAssignType: group, owner: test:groupTestAttrAssign, attributeDefNameNameName test:testAttributeAssignDefName, action: assign, values: 15,5,5, enable: T, id: a9c83eeb78c04ae5befcea36272d318c, changed: true, valuesChanged: false
13508       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F), changed\: (T|F), valuesChanged\: (T|F)$
13509       Pattern pattern = Pattern
13510         .compile("^Index\\: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName\\: (.+), action\\: (.+), " +
13511             "values\\: (.+), enabled\\: (T|F), id\\: (.+), changed\\: (T|F), deleted\\: (T|F), valuesChanged\\: (T|F)$");
13512       String outputLine = outputLines[0];
13513 
13514       Matcher matcher = pattern.matcher(outputLines[0]);
13515 
13516       assertTrue(outputLine, matcher.matches());
13517       assertEquals(outputLine, "0", matcher.group(1));
13518       assertEquals(outputLine, "group", matcher.group(2));
13519       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
13520       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
13521       assertEquals(outputLine, "assign", matcher.group(5));
13522       assertEquals(outputLine, "none", matcher.group(6));
13523       assertEquals(outputLine, "T", matcher.group(7));
13524       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
13525       assertEquals(outputLine, "T", matcher.group(9));
13526       assertEquals(outputLine, "F", matcher.group(10));
13527       assertEquals(outputLine, "F", matcher.group(11));
13528 
13529       assertTrue(GrouperClientWs.mostRecentRequest,
13530           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
13531       assertTrue(GrouperClientWs.mostRecentRequest,
13532           !GrouperClientWs.mostRecentRequest.contains("actions"));
13533       assertTrue(GrouperClientWs.mostRecentRequest,
13534           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
13535       assertTrue(GrouperClientWs.mostRecentRequest,
13536           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
13537       assertTrue(GrouperClientWs.mostRecentRequest,
13538           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
13539       assertTrue(GrouperClientWs.mostRecentRequest,
13540           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
13541       assertTrue(GrouperClientWs.mostRecentRequest,
13542           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
13543       assertTrue(GrouperClientWs.mostRecentRequest,
13544           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
13545       assertTrue(GrouperClientWs.mostRecentRequest,
13546           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
13547       assertTrue(GrouperClientWs.mostRecentRequest,
13548           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
13549       assertTrue(GrouperClientWs.mostRecentRequest,
13550           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
13551       assertTrue(GrouperClientWs.mostRecentRequest,
13552           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
13553       assertTrue(GrouperClientWs.mostRecentRequest,
13554           !GrouperClientWs.mostRecentRequest.contains("params"));
13555       assertTrue(GrouperClientWs.mostRecentRequest,
13556           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
13557       assertTrue(GrouperClientWs.mostRecentRequest,
13558           !GrouperClientWs.mostRecentRequest.contains("values"));
13559       assertTrue(GrouperClientWs.mostRecentRequest,
13560           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
13561       assertTrue(GrouperClientWs.mostRecentRequest,
13562           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
13563           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
13564       assertTrue(GrouperClientWs.mostRecentRequest,
13565           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
13566       assertTrue(GrouperClientWs.mostRecentRequest,
13567           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
13568       assertTrue(GrouperClientWs.mostRecentRequest,
13569           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
13570           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
13571       assertTrue(GrouperClientWs.mostRecentRequest,
13572           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
13573       assertTrue(GrouperClientWs.mostRecentRequest,
13574           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
13575       assertTrue(GrouperClientWs.mostRecentRequest,
13576           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
13577       assertTrue(GrouperClientWs.mostRecentRequest,
13578           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
13579 
13580 
13581       // ######################################################
13582       // Try attributeDefNameId
13583 
13584       baos = new ByteArrayOutputStream();
13585       System.setOut(new PrintStream(baos));
13586 
13587       GrouperClient.main(GrouperClientUtils.splitTrim(
13588           "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=assign_attr " +
13589           "--attributeDefNameUuids=" + attributeDefName.getId() +  " --ownerGroupNames=test:groupTestAttrAssign",
13590           " "));
13591 
13592       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
13593 
13594       System.out.flush();
13595       output = new String(baos.toByteArray());
13596 
13597       System.setOut(systemOut);
13598 
13599       outputLines = GrouperClientUtils.splitTrim(output, "\n");
13600 
13601       outputLine = outputLines[0];
13602 
13603       matcher = pattern.matcher(outputLines[0]);
13604 
13605       assertTrue(outputLine, matcher.matches());
13606       assertEquals(outputLine, "0", matcher.group(1));
13607       assertEquals(outputLine, "group", matcher.group(2));
13608       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
13609       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
13610       assertEquals(outputLine, "assign", matcher.group(5));
13611       assertEquals(outputLine, "none", matcher.group(6));
13612       assertEquals(outputLine, "T", matcher.group(7));
13613       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
13614       assertEquals(outputLine, "F", matcher.group(9));
13615       assertEquals(outputLine, "F", matcher.group(10));
13616 
13617       assertTrue(GrouperClientWs.mostRecentRequest,
13618           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
13619       assertTrue(GrouperClientWs.mostRecentRequest,
13620           !GrouperClientWs.mostRecentRequest.contains("actions"));
13621       assertTrue(GrouperClientWs.mostRecentRequest,
13622           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
13623       assertTrue(GrouperClientWs.mostRecentRequest,
13624           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
13625       assertTrue(GrouperClientWs.mostRecentRequest,
13626           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
13627       assertTrue(GrouperClientWs.mostRecentRequest,
13628           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
13629       assertTrue(GrouperClientWs.mostRecentRequest,
13630           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
13631       assertTrue(GrouperClientWs.mostRecentRequest,
13632           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
13633       assertTrue(GrouperClientWs.mostRecentRequest,
13634           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
13635       assertTrue(GrouperClientWs.mostRecentRequest,
13636           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
13637       assertTrue(GrouperClientWs.mostRecentRequest,
13638           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
13639       assertTrue(GrouperClientWs.mostRecentRequest,
13640           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
13641       assertTrue(GrouperClientWs.mostRecentRequest,
13642           !GrouperClientWs.mostRecentRequest.contains("params"));
13643       assertTrue(GrouperClientWs.mostRecentRequest,
13644           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
13645       assertTrue(GrouperClientWs.mostRecentRequest,
13646           !GrouperClientWs.mostRecentRequest.contains("values"));
13647       assertTrue(GrouperClientWs.mostRecentRequest,
13648           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
13649       assertTrue(GrouperClientWs.mostRecentRequest,
13650           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
13651           && GrouperClientWs.mostRecentRequest.contains(attributeDefName.getId()));
13652       assertTrue(GrouperClientWs.mostRecentRequest,
13653           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
13654       assertTrue(GrouperClientWs.mostRecentRequest,
13655           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
13656       assertTrue(GrouperClientWs.mostRecentRequest,
13657           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
13658           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
13659       assertTrue(GrouperClientWs.mostRecentRequest,
13660           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
13661       assertTrue(GrouperClientWs.mostRecentRequest,
13662           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
13663       assertTrue(GrouperClientWs.mostRecentRequest,
13664           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
13665       assertTrue(GrouperClientWs.mostRecentRequest,
13666           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
13667 
13668       // ######################################################
13669       // Try attributeDefNameIdIndex
13670 
13671       baos = new ByteArrayOutputStream();
13672       System.setOut(new PrintStream(baos));
13673 
13674       GrouperClient.main(GrouperClientUtils.splitTrim(
13675           "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=assign_attr " +
13676           "--attributeDefNameIdIndexes=" + attributeDefName.getIdIndex() +  " --ownerGroupNames=test:groupTestAttrAssign",
13677           " "));
13678 
13679       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
13680 
13681       System.out.flush();
13682       output = new String(baos.toByteArray());
13683 
13684       System.setOut(systemOut);
13685 
13686       outputLines = GrouperClientUtils.splitTrim(output, "\n");
13687 
13688       outputLine = outputLines[0];
13689 
13690       matcher = pattern.matcher(outputLines[0]);
13691 
13692       assertTrue(outputLine, matcher.matches());
13693       assertEquals(outputLine, "0", matcher.group(1));
13694       assertEquals(outputLine, "group", matcher.group(2));
13695       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
13696       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
13697       assertEquals(outputLine, "assign", matcher.group(5));
13698       assertEquals(outputLine, "none", matcher.group(6));
13699       assertEquals(outputLine, "T", matcher.group(7));
13700       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
13701       assertEquals(outputLine, "F", matcher.group(9));
13702       assertEquals(outputLine, "F", matcher.group(10));
13703 
13704       assertTrue(GrouperClientWs.mostRecentRequest,
13705           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
13706       assertTrue(GrouperClientWs.mostRecentRequest,
13707           !GrouperClientWs.mostRecentRequest.contains("actions"));
13708       assertTrue(GrouperClientWs.mostRecentRequest,
13709           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
13710       assertTrue(GrouperClientWs.mostRecentRequest,
13711           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
13712       assertTrue(GrouperClientWs.mostRecentRequest,
13713           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
13714       assertTrue(GrouperClientWs.mostRecentRequest,
13715           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
13716       assertTrue(GrouperClientWs.mostRecentRequest,
13717           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
13718       assertTrue(GrouperClientWs.mostRecentRequest,
13719           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
13720       assertTrue(GrouperClientWs.mostRecentRequest,
13721           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
13722       assertTrue(GrouperClientWs.mostRecentRequest,
13723           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
13724       assertTrue(GrouperClientWs.mostRecentRequest,
13725           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
13726       assertTrue(GrouperClientWs.mostRecentRequest,
13727           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
13728       assertTrue(GrouperClientWs.mostRecentRequest,
13729           !GrouperClientWs.mostRecentRequest.contains("params"));
13730       assertTrue(GrouperClientWs.mostRecentRequest,
13731           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
13732       assertTrue(GrouperClientWs.mostRecentRequest,
13733           !GrouperClientWs.mostRecentRequest.contains("values"));
13734       assertTrue(GrouperClientWs.mostRecentRequest,
13735           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
13736       assertTrue(GrouperClientWs.mostRecentRequest,
13737           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
13738           && GrouperClientWs.mostRecentRequest.contains(attributeDefName.getIdIndex().toString()));
13739       assertTrue(GrouperClientWs.mostRecentRequest,
13740           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
13741       assertTrue(GrouperClientWs.mostRecentRequest,
13742           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
13743       assertTrue(GrouperClientWs.mostRecentRequest,
13744           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
13745           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
13746       assertTrue(GrouperClientWs.mostRecentRequest,
13747           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
13748       assertTrue(GrouperClientWs.mostRecentRequest,
13749           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
13750       assertTrue(GrouperClientWs.mostRecentRequest,
13751           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
13752       assertTrue(GrouperClientWs.mostRecentRequest,
13753           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
13754 
13755       // ######################################################
13756       // Try ownerGroupUuid
13757 
13758       baos = new ByteArrayOutputStream();
13759       System.setOut(new PrintStream(baos));
13760 
13761       GrouperClient.main(GrouperClientUtils.splitTrim(
13762           "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=assign_attr " +
13763           "--attributeDefNameNames=test:testAttributeAssignDefName --ownerGroupUuids=" + group.getUuid(),
13764           " "));
13765 
13766       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
13767 
13768       System.out.flush();
13769       output = new String(baos.toByteArray());
13770 
13771       System.setOut(systemOut);
13772 
13773       outputLines = GrouperClientUtils.splitTrim(output, "\n");
13774 
13775       outputLine = outputLines[0];
13776 
13777       matcher = pattern.matcher(outputLines[0]);
13778 
13779       assertTrue(outputLine, matcher.matches());
13780       assertEquals(outputLine, "0", matcher.group(1));
13781       assertEquals(outputLine, "group", matcher.group(2));
13782       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
13783       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
13784       assertEquals(outputLine, "assign", matcher.group(5));
13785       assertEquals(outputLine, "none", matcher.group(6));
13786       assertEquals(outputLine, "T", matcher.group(7));
13787       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
13788       assertEquals(outputLine, "F", matcher.group(9));
13789       assertEquals(outputLine, "F", matcher.group(10));
13790       assertEquals(outputLine, "F", matcher.group(11));
13791 
13792       assertTrue(GrouperClientWs.mostRecentRequest,
13793           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
13794       assertTrue(GrouperClientWs.mostRecentRequest,
13795           !GrouperClientWs.mostRecentRequest.contains("actions"));
13796       assertTrue(GrouperClientWs.mostRecentRequest,
13797           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
13798       assertTrue(GrouperClientWs.mostRecentRequest,
13799           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
13800       assertTrue(GrouperClientWs.mostRecentRequest,
13801           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
13802       assertTrue(GrouperClientWs.mostRecentRequest,
13803           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
13804       assertTrue(GrouperClientWs.mostRecentRequest,
13805           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
13806       assertTrue(GrouperClientWs.mostRecentRequest,
13807           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
13808       assertTrue(GrouperClientWs.mostRecentRequest,
13809           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
13810       assertTrue(GrouperClientWs.mostRecentRequest,
13811           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
13812       assertTrue(GrouperClientWs.mostRecentRequest,
13813           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
13814       assertTrue(GrouperClientWs.mostRecentRequest,
13815           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
13816       assertTrue(GrouperClientWs.mostRecentRequest,
13817           !GrouperClientWs.mostRecentRequest.contains("params"));
13818       assertTrue(GrouperClientWs.mostRecentRequest,
13819           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
13820       assertTrue(GrouperClientWs.mostRecentRequest,
13821           !GrouperClientWs.mostRecentRequest.contains("values"));
13822       assertTrue(GrouperClientWs.mostRecentRequest,
13823           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
13824       assertTrue(GrouperClientWs.mostRecentRequest,
13825           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
13826           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
13827       assertTrue(GrouperClientWs.mostRecentRequest,
13828           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
13829       assertTrue(GrouperClientWs.mostRecentRequest,
13830           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
13831       assertTrue(GrouperClientWs.mostRecentRequest,
13832           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
13833           && GrouperClientWs.mostRecentRequest.contains(group.getUuid()));
13834       assertTrue(GrouperClientWs.mostRecentRequest,
13835           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
13836       assertTrue(GrouperClientWs.mostRecentRequest,
13837           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
13838       assertTrue(GrouperClientWs.mostRecentRequest,
13839           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
13840       assertTrue(GrouperClientWs.mostRecentRequest,
13841           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
13842 
13843       // ######################################################
13844       // Try ownerGroupIdIndex
13845 
13846       baos = new ByteArrayOutputStream();
13847       System.setOut(new PrintStream(baos));
13848 
13849       GrouperClient.main(GrouperClientUtils.splitTrim(
13850           "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=assign_attr " +
13851           "--attributeDefNameNames=test:testAttributeAssignDefName --ownerGroupIdIndexes=" + group.getIdIndex(),
13852           " "));
13853 
13854       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
13855 
13856       System.out.flush();
13857       output = new String(baos.toByteArray());
13858 
13859       System.setOut(systemOut);
13860 
13861       outputLines = GrouperClientUtils.splitTrim(output, "\n");
13862 
13863       outputLine = outputLines[0];
13864 
13865       matcher = pattern.matcher(outputLines[0]);
13866 
13867       assertTrue(outputLine, matcher.matches());
13868       assertEquals(outputLine, "0", matcher.group(1));
13869       assertEquals(outputLine, "group", matcher.group(2));
13870       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
13871       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
13872       assertEquals(outputLine, "assign", matcher.group(5));
13873       assertEquals(outputLine, "none", matcher.group(6));
13874       assertEquals(outputLine, "T", matcher.group(7));
13875       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
13876       assertEquals(outputLine, "F", matcher.group(9));
13877       assertEquals(outputLine, "F", matcher.group(10));
13878       assertEquals(outputLine, "F", matcher.group(11));
13879 
13880       assertTrue(GrouperClientWs.mostRecentRequest,
13881           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
13882       assertTrue(GrouperClientWs.mostRecentRequest,
13883           !GrouperClientWs.mostRecentRequest.contains("actions"));
13884       assertTrue(GrouperClientWs.mostRecentRequest,
13885           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
13886       assertTrue(GrouperClientWs.mostRecentRequest,
13887           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
13888       assertTrue(GrouperClientWs.mostRecentRequest,
13889           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
13890       assertTrue(GrouperClientWs.mostRecentRequest,
13891           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
13892       assertTrue(GrouperClientWs.mostRecentRequest,
13893           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
13894       assertTrue(GrouperClientWs.mostRecentRequest,
13895           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
13896       assertTrue(GrouperClientWs.mostRecentRequest,
13897           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
13898       assertTrue(GrouperClientWs.mostRecentRequest,
13899           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
13900       assertTrue(GrouperClientWs.mostRecentRequest,
13901           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
13902       assertTrue(GrouperClientWs.mostRecentRequest,
13903           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
13904       assertTrue(GrouperClientWs.mostRecentRequest,
13905           !GrouperClientWs.mostRecentRequest.contains("params"));
13906       assertTrue(GrouperClientWs.mostRecentRequest,
13907           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
13908       assertTrue(GrouperClientWs.mostRecentRequest,
13909           !GrouperClientWs.mostRecentRequest.contains("values"));
13910       assertTrue(GrouperClientWs.mostRecentRequest,
13911           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
13912       assertTrue(GrouperClientWs.mostRecentRequest,
13913           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
13914           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
13915       assertTrue(GrouperClientWs.mostRecentRequest,
13916           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
13917       assertTrue(GrouperClientWs.mostRecentRequest,
13918           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
13919       assertTrue(GrouperClientWs.mostRecentRequest,
13920           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
13921           && GrouperClientWs.mostRecentRequest.contains(group.getIdIndex().toString()));
13922       assertTrue(GrouperClientWs.mostRecentRequest,
13923           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
13924       assertTrue(GrouperClientWs.mostRecentRequest,
13925           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
13926       assertTrue(GrouperClientWs.mostRecentRequest,
13927           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
13928       assertTrue(GrouperClientWs.mostRecentRequest,
13929           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
13930 
13931       // ######################################################
13932       // Try enabledTime
13933 
13934       baos = new ByteArrayOutputStream();
13935       System.setOut(new PrintStream(baos));
13936 
13937       GrouperClient.main(GrouperClientUtils.splitTrim(
13938           "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=assign_attr " +
13939           "--attributeDefNameNames=test:testAttributeAssignDefName --ownerGroupNames=test:groupTestAttrAssign "
13940           + " --assignmentEnabledTime=2010/03/05_17:05:13.123",
13941           " "));
13942 
13943       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
13944 
13945       System.out.flush();
13946       output = new String(baos.toByteArray());
13947 
13948       System.setOut(systemOut);
13949 
13950       outputLines = GrouperClientUtils.splitTrim(output, "\n");
13951 
13952       outputLine = outputLines[0];
13953 
13954       matcher = pattern.matcher(outputLines[0]);
13955 
13956       assertTrue(outputLine, matcher.matches());
13957       assertEquals(outputLine, "0", matcher.group(1));
13958       assertEquals(outputLine, "group", matcher.group(2));
13959       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
13960       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
13961       assertEquals(outputLine, "assign", matcher.group(5));
13962       assertEquals(outputLine, "none", matcher.group(6));
13963       assertEquals(outputLine, "T", matcher.group(7));
13964       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
13965       assertEquals(outputLine, "T", matcher.group(9));
13966       assertEquals(outputLine, "F", matcher.group(10));
13967 
13968       assertTrue(GrouperClientWs.mostRecentRequest,
13969           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
13970       assertTrue(GrouperClientWs.mostRecentRequest,
13971           !GrouperClientWs.mostRecentRequest.contains("actions"));
13972       assertTrue(GrouperClientWs.mostRecentRequest,
13973           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
13974       assertTrue(GrouperClientWs.mostRecentRequest,
13975           GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime")
13976           && GrouperClientWs.mostRecentRequest.contains("2010/03/05 17:05:13.123"));
13977       assertTrue(GrouperClientWs.mostRecentResponse,
13978           GrouperClientWs.mostRecentResponse.contains("2010/03/05 17:05:13.123"));
13979       assertTrue(GrouperClientWs.mostRecentRequest,
13980           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
13981       assertTrue(GrouperClientWs.mostRecentRequest,
13982           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
13983       assertTrue(GrouperClientWs.mostRecentRequest,
13984           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
13985       assertTrue(GrouperClientWs.mostRecentRequest,
13986           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
13987       assertTrue(GrouperClientWs.mostRecentRequest,
13988           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
13989       assertTrue(GrouperClientWs.mostRecentRequest,
13990           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
13991       assertTrue(GrouperClientWs.mostRecentRequest,
13992           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
13993       assertTrue(GrouperClientWs.mostRecentRequest,
13994           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
13995       assertTrue(GrouperClientWs.mostRecentRequest,
13996           !GrouperClientWs.mostRecentRequest.contains("params"));
13997       assertTrue(GrouperClientWs.mostRecentRequest,
13998           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
13999       assertTrue(GrouperClientWs.mostRecentRequest,
14000           !GrouperClientWs.mostRecentRequest.contains("values"));
14001       assertTrue(GrouperClientWs.mostRecentRequest,
14002           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
14003       assertTrue(GrouperClientWs.mostRecentRequest,
14004           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
14005           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
14006       assertTrue(GrouperClientWs.mostRecentRequest,
14007           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
14008       assertTrue(GrouperClientWs.mostRecentRequest,
14009           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
14010       assertTrue(GrouperClientWs.mostRecentRequest,
14011           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
14012           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
14013       assertTrue(GrouperClientWs.mostRecentRequest,
14014           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
14015       assertTrue(GrouperClientWs.mostRecentRequest,
14016           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
14017       assertTrue(GrouperClientWs.mostRecentRequest,
14018           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
14019       assertTrue(GrouperClientWs.mostRecentRequest,
14020           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
14021 
14022       // ######################################################
14023       // Try disabledTime
14024 
14025       baos = new ByteArrayOutputStream();
14026       System.setOut(new PrintStream(baos));
14027 
14028       GrouperClient.main(GrouperClientUtils.splitTrim(
14029           "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=assign_attr " +
14030           "--attributeDefNameNames=test:testAttributeAssignDefName --ownerGroupNames=test:groupTestAttrAssign "
14031           + " --assignmentDisabledTime=2010/03/05_17:05:13.123",
14032           " "));
14033 
14034       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
14035 
14036       System.out.flush();
14037       output = new String(baos.toByteArray());
14038 
14039       System.setOut(systemOut);
14040 
14041       outputLines = GrouperClientUtils.splitTrim(output, "\n");
14042 
14043       outputLine = outputLines[0];
14044 
14045       matcher = pattern.matcher(outputLines[0]);
14046 
14047       assertTrue(outputLine, matcher.matches());
14048       assertEquals(outputLine, "0", matcher.group(1));
14049       assertEquals(outputLine, "group", matcher.group(2));
14050       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
14051       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
14052       assertEquals(outputLine, "assign", matcher.group(5));
14053       assertEquals(outputLine, "none", matcher.group(6));
14054       assertEquals(outputLine, "F", matcher.group(7));
14055       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
14056       assertEquals(outputLine, "T", matcher.group(9));
14057       assertEquals(outputLine, "F", matcher.group(10));
14058 
14059       assertTrue(GrouperClientWs.mostRecentRequest,
14060           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
14061       assertTrue(GrouperClientWs.mostRecentRequest,
14062           !GrouperClientWs.mostRecentRequest.contains("actions"));
14063       assertTrue(GrouperClientWs.mostRecentRequest,
14064           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
14065       assertTrue(GrouperClientWs.mostRecentRequest,
14066           GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime")
14067           && GrouperClientWs.mostRecentRequest.contains("2010/03/05 17:05:13.123"));
14068       assertTrue(GrouperClientWs.mostRecentResponse,
14069           GrouperClientWs.mostRecentResponse.contains("2010/03/05 17:05:13.123"));
14070       assertTrue(GrouperClientWs.mostRecentRequest,
14071           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
14072       assertTrue(GrouperClientWs.mostRecentRequest,
14073           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
14074       assertTrue(GrouperClientWs.mostRecentRequest,
14075           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
14076       assertTrue(GrouperClientWs.mostRecentRequest,
14077           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
14078       assertTrue(GrouperClientWs.mostRecentRequest,
14079           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
14080       assertTrue(GrouperClientWs.mostRecentRequest,
14081           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
14082       assertTrue(GrouperClientWs.mostRecentRequest,
14083           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
14084       assertTrue(GrouperClientWs.mostRecentRequest,
14085           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
14086       assertTrue(GrouperClientWs.mostRecentRequest,
14087           !GrouperClientWs.mostRecentRequest.contains("params"));
14088       assertTrue(GrouperClientWs.mostRecentRequest,
14089           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
14090       assertTrue(GrouperClientWs.mostRecentRequest,
14091           !GrouperClientWs.mostRecentRequest.contains("values"));
14092       assertTrue(GrouperClientWs.mostRecentRequest,
14093           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
14094       assertTrue(GrouperClientWs.mostRecentRequest,
14095           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
14096           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
14097       assertTrue(GrouperClientWs.mostRecentRequest,
14098           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
14099       assertTrue(GrouperClientWs.mostRecentRequest,
14100           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
14101       assertTrue(GrouperClientWs.mostRecentRequest,
14102           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
14103           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
14104       assertTrue(GrouperClientWs.mostRecentRequest,
14105           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
14106       assertTrue(GrouperClientWs.mostRecentRequest,
14107           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
14108       assertTrue(GrouperClientWs.mostRecentRequest,
14109           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
14110       assertTrue(GrouperClientWs.mostRecentRequest,
14111           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
14112 
14113       // ######################################################
14114       // Try assignmentNotes
14115 
14116       baos = new ByteArrayOutputStream();
14117       System.setOut(new PrintStream(baos));
14118 
14119       GrouperClient.main(GrouperClientUtils.splitTrim(
14120           "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=assign_attr " +
14121           "--attributeDefNameNames=test:testAttributeAssignDefName --ownerGroupNames=test:groupTestAttrAssign "
14122           + " --assignmentNotes=theNotes",
14123           " "));
14124 
14125       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
14126 
14127       System.out.flush();
14128       output = new String(baos.toByteArray());
14129 
14130       System.setOut(systemOut);
14131 
14132       outputLines = GrouperClientUtils.splitTrim(output, "\n");
14133 
14134       outputLine = outputLines[0];
14135 
14136       matcher = pattern.matcher(outputLines[0]);
14137 
14138       assertTrue(outputLine, matcher.matches());
14139       assertEquals(outputLine, "0", matcher.group(1));
14140       assertEquals(outputLine, "group", matcher.group(2));
14141       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
14142       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
14143       assertEquals(outputLine, "assign", matcher.group(5));
14144       assertEquals(outputLine, "none", matcher.group(6));
14145       assertEquals(outputLine, "T", matcher.group(7));
14146       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
14147       assertEquals(outputLine, "T", matcher.group(9));
14148       assertEquals(outputLine, "F", matcher.group(10));
14149 
14150       assertTrue(GrouperClientWs.mostRecentRequest,
14151           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
14152       assertTrue(GrouperClientWs.mostRecentRequest,
14153           !GrouperClientWs.mostRecentRequest.contains("actions"));
14154       assertTrue(GrouperClientWs.mostRecentRequest,
14155           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
14156       assertTrue(GrouperClientWs.mostRecentRequest,
14157           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
14158       assertTrue(GrouperClientWs.mostRecentResponse,
14159           GrouperClientWs.mostRecentResponse.contains("theNotes"));
14160       assertTrue(GrouperClientWs.mostRecentRequest,
14161           GrouperClientWs.mostRecentRequest.contains("assignmentNotes")
14162           && GrouperClientWs.mostRecentRequest.contains("theNotes") );
14163       assertTrue(GrouperClientWs.mostRecentRequest,
14164           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
14165       assertTrue(GrouperClientWs.mostRecentRequest,
14166           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
14167       assertTrue(GrouperClientWs.mostRecentRequest,
14168           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
14169       assertTrue(GrouperClientWs.mostRecentRequest,
14170           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
14171       assertTrue(GrouperClientWs.mostRecentRequest,
14172           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
14173       assertTrue(GrouperClientWs.mostRecentRequest,
14174           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
14175       assertTrue(GrouperClientWs.mostRecentRequest,
14176           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
14177       assertTrue(GrouperClientWs.mostRecentRequest,
14178           !GrouperClientWs.mostRecentRequest.contains("params"));
14179       assertTrue(GrouperClientWs.mostRecentRequest,
14180           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
14181       assertTrue(GrouperClientWs.mostRecentRequest,
14182           !GrouperClientWs.mostRecentRequest.contains("values"));
14183       assertTrue(GrouperClientWs.mostRecentRequest,
14184           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
14185       assertTrue(GrouperClientWs.mostRecentRequest,
14186           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
14187           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
14188       assertTrue(GrouperClientWs.mostRecentRequest,
14189           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
14190       assertTrue(GrouperClientWs.mostRecentRequest,
14191           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
14192       assertTrue(GrouperClientWs.mostRecentRequest,
14193           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
14194           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
14195       assertTrue(GrouperClientWs.mostRecentRequest,
14196           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
14197       assertTrue(GrouperClientWs.mostRecentRequest,
14198           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
14199       assertTrue(GrouperClientWs.mostRecentRequest,
14200           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
14201       assertTrue(GrouperClientWs.mostRecentRequest,
14202           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
14203 
14204 
14205       // ######################################################
14206       // Try delegatable
14207 
14208       baos = new ByteArrayOutputStream();
14209       System.setOut(new PrintStream(baos));
14210 
14211       GrouperClient.main(GrouperClientUtils.splitTrim(
14212           "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=assign_attr " +
14213           "--attributeDefNameNames=test:testAttributeAssignDefName --ownerGroupNames=test:groupTestAttrAssign "
14214           + " --delegatable=FALSE",
14215           " "));
14216 
14217       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
14218 
14219       System.out.flush();
14220       output = new String(baos.toByteArray());
14221 
14222       System.setOut(systemOut);
14223 
14224       outputLines = GrouperClientUtils.splitTrim(output, "\n");
14225 
14226       outputLine = outputLines[0];
14227 
14228       matcher = pattern.matcher(outputLines[0]);
14229 
14230       assertTrue(outputLine, matcher.matches());
14231       assertEquals(outputLine, "0", matcher.group(1));
14232       assertEquals(outputLine, "group", matcher.group(2));
14233       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
14234       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
14235       assertEquals(outputLine, "assign", matcher.group(5));
14236       assertEquals(outputLine, "none", matcher.group(6));
14237       assertEquals(outputLine, "T", matcher.group(7));
14238       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
14239       assertEquals(outputLine, "T", matcher.group(9));
14240       assertEquals(outputLine, "F", matcher.group(10));
14241 
14242       assertTrue(GrouperClientWs.mostRecentRequest,
14243           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
14244       assertTrue(GrouperClientWs.mostRecentRequest,
14245           !GrouperClientWs.mostRecentRequest.contains("actions"));
14246       assertTrue(GrouperClientWs.mostRecentRequest,
14247           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
14248       assertTrue(GrouperClientWs.mostRecentRequest,
14249           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
14250       //assertTrue(GrouperClientWs.mostRecentResponse,
14251       //    GrouperClientWs.mostRecentResponse.contains("theNotes"));
14252       assertTrue(GrouperClientWs.mostRecentRequest,
14253           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
14254       assertTrue(GrouperClientWs.mostRecentRequest,
14255           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
14256       assertTrue(GrouperClientWs.mostRecentRequest,
14257           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
14258       assertTrue(GrouperClientWs.mostRecentRequest,
14259           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
14260       assertTrue(GrouperClientWs.mostRecentRequest,
14261           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
14262       assertTrue(GrouperClientWs.mostRecentRequest,
14263           GrouperClientWs.mostRecentRequest.contains("delegatable")
14264           && GrouperClientWs.mostRecentRequest.contains("FALSE"));
14265       assertTrue(GrouperClientWs.mostRecentRequest,
14266           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
14267       assertTrue(GrouperClientWs.mostRecentRequest,
14268           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
14269       assertTrue(GrouperClientWs.mostRecentRequest,
14270           !GrouperClientWs.mostRecentRequest.contains("params"));
14271       assertTrue(GrouperClientWs.mostRecentRequest,
14272           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
14273       assertTrue(GrouperClientWs.mostRecentRequest,
14274           !GrouperClientWs.mostRecentRequest.contains("values"));
14275       assertTrue(GrouperClientWs.mostRecentRequest,
14276           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
14277       assertTrue(GrouperClientWs.mostRecentRequest,
14278           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
14279           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
14280       assertTrue(GrouperClientWs.mostRecentRequest,
14281           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
14282       assertTrue(GrouperClientWs.mostRecentRequest,
14283           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
14284       assertTrue(GrouperClientWs.mostRecentRequest,
14285           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
14286           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
14287       assertTrue(GrouperClientWs.mostRecentRequest,
14288           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
14289       assertTrue(GrouperClientWs.mostRecentRequest,
14290           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
14291       assertTrue(GrouperClientWs.mostRecentRequest,
14292           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
14293       assertTrue(GrouperClientWs.mostRecentRequest,
14294           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
14295 
14296       // ######################################################
14297       // Try actions
14298 
14299       baos = new ByteArrayOutputStream();
14300       System.setOut(new PrintStream(baos));
14301 
14302       GrouperClient.main(GrouperClientUtils.splitTrim(
14303           "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=assign_attr " +
14304           "--attributeDefNameNames=test:testAttributeAssignDefName --ownerGroupNames=test:groupTestAttrAssign "
14305           + " --actions=assign",
14306           " "));
14307 
14308       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
14309 
14310       System.out.flush();
14311       output = new String(baos.toByteArray());
14312 
14313       System.setOut(systemOut);
14314 
14315       outputLines = GrouperClientUtils.splitTrim(output, "\n");
14316 
14317       outputLine = outputLines[0];
14318 
14319       matcher = pattern.matcher(outputLines[0]);
14320 
14321       assertTrue(outputLine, matcher.matches());
14322       assertEquals(outputLine, "0", matcher.group(1));
14323       assertEquals(outputLine, "group", matcher.group(2));
14324       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
14325       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
14326       assertEquals(outputLine, "assign", matcher.group(5));
14327       assertEquals(outputLine, "none", matcher.group(6));
14328       assertEquals(outputLine, "T", matcher.group(7));
14329       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
14330       assertEquals(outputLine, "F", matcher.group(9));
14331       assertEquals(outputLine, "F", matcher.group(10));
14332 
14333       assertTrue(GrouperClientWs.mostRecentRequest,
14334           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
14335       assertTrue(GrouperClientWs.mostRecentRequest,
14336           GrouperClientWs.mostRecentRequest.contains("actions"));
14337       assertTrue(GrouperClientWs.mostRecentRequest,
14338           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
14339       assertTrue(GrouperClientWs.mostRecentRequest,
14340           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
14341       //assertTrue(GrouperClientWs.mostRecentResponse,
14342       //    GrouperClientWs.mostRecentResponse.contains("theNotes"));
14343       assertTrue(GrouperClientWs.mostRecentRequest,
14344           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
14345       assertTrue(GrouperClientWs.mostRecentRequest,
14346           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
14347       assertTrue(GrouperClientWs.mostRecentRequest,
14348           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
14349       assertTrue(GrouperClientWs.mostRecentRequest,
14350           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
14351       assertTrue(GrouperClientWs.mostRecentRequest,
14352           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
14353       assertTrue(GrouperClientWs.mostRecentRequest,
14354           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
14355       assertTrue(GrouperClientWs.mostRecentRequest,
14356           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
14357       assertTrue(GrouperClientWs.mostRecentRequest,
14358           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
14359       assertTrue(GrouperClientWs.mostRecentRequest,
14360           !GrouperClientWs.mostRecentRequest.contains("params"));
14361       assertTrue(GrouperClientWs.mostRecentRequest,
14362           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
14363       assertTrue(GrouperClientWs.mostRecentRequest,
14364           !GrouperClientWs.mostRecentRequest.contains("values"));
14365       assertTrue(GrouperClientWs.mostRecentRequest,
14366           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
14367       assertTrue(GrouperClientWs.mostRecentRequest,
14368           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
14369           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
14370       assertTrue(GrouperClientWs.mostRecentRequest,
14371           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
14372       assertTrue(GrouperClientWs.mostRecentRequest,
14373           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
14374       assertTrue(GrouperClientWs.mostRecentRequest,
14375           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
14376           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
14377       assertTrue(GrouperClientWs.mostRecentRequest,
14378           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
14379       assertTrue(GrouperClientWs.mostRecentRequest,
14380           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
14381       assertTrue(GrouperClientWs.mostRecentRequest,
14382           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
14383       assertTrue(GrouperClientWs.mostRecentRequest,
14384           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
14385 
14386       // ######################################################
14387       // Try values
14388 
14389       baos = new ByteArrayOutputStream();
14390       System.setOut(new PrintStream(baos));
14391 
14392       GrouperClient.main(GrouperClientUtils.splitTrim(
14393           "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=assign_attr " +
14394           "--attributeDefNameNames=test:testAttributeAssignDefName --ownerGroupNames=test:groupTestAttrAssign "
14395           + " --values0System=3 --values1System=4 --values2System=5 --attributeAssignValueOperation=replace_values",
14396           " "));
14397 
14398       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
14399 
14400       System.out.flush();
14401       output = new String(baos.toByteArray());
14402 
14403       System.setOut(systemOut);
14404 
14405       outputLines = GrouperClientUtils.splitTrim(output, "\n");
14406 
14407       outputLine = outputLines[0];
14408 
14409       matcher = pattern.matcher(outputLines[0]);
14410 
14411       assertTrue(outputLine, matcher.matches());
14412       assertEquals(outputLine, "0", matcher.group(1));
14413       assertEquals(outputLine, "group", matcher.group(2));
14414       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
14415       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
14416       assertEquals(outputLine, "assign", matcher.group(5));
14417       assertEquals(outputLine, "3,4,5", matcher.group(6));
14418       assertEquals(outputLine, "T", matcher.group(7));
14419       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
14420       assertEquals(outputLine, "F", matcher.group(9));
14421       assertEquals(outputLine, "F", matcher.group(10));
14422       assertEquals(outputLine, "T", matcher.group(11));
14423 
14424       assertTrue(GrouperClientWs.mostRecentRequest,
14425           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
14426       assertTrue(GrouperClientWs.mostRecentRequest,
14427           !GrouperClientWs.mostRecentRequest.contains("actions"));
14428       assertTrue(GrouperClientWs.mostRecentRequest,
14429           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
14430       assertTrue(GrouperClientWs.mostRecentRequest,
14431           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
14432       //assertTrue(GrouperClientWs.mostRecentResponse,
14433       //    GrouperClientWs.mostRecentResponse.contains("theNotes"));
14434       assertTrue(GrouperClientWs.mostRecentRequest,
14435           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
14436       assertTrue(GrouperClientWs.mostRecentRequest,
14437           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
14438       assertTrue(GrouperClientWs.mostRecentRequest,
14439           GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
14440       assertTrue(GrouperClientWs.mostRecentRequest,
14441           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
14442       assertTrue(GrouperClientWs.mostRecentRequest,
14443           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
14444       assertTrue(GrouperClientWs.mostRecentRequest,
14445           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
14446       assertTrue(GrouperClientWs.mostRecentRequest,
14447           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
14448       assertTrue(GrouperClientWs.mostRecentRequest,
14449           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
14450       assertTrue(GrouperClientWs.mostRecentRequest,
14451           !GrouperClientWs.mostRecentRequest.contains("params"));
14452       assertTrue(GrouperClientWs.mostRecentRequest,
14453           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
14454       assertTrue(GrouperClientWs.mostRecentRequest,
14455           GrouperClientWs.mostRecentRequest.contains("values")
14456           && GrouperClientWs.mostRecentRequest.contains(">3<")
14457           && GrouperClientWs.mostRecentRequest.contains(">4<")
14458           && GrouperClientWs.mostRecentRequest.contains(">5<"));
14459       assertTrue(GrouperClientWs.mostRecentRequest,
14460           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
14461       assertTrue(GrouperClientWs.mostRecentRequest,
14462           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
14463           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
14464       assertTrue(GrouperClientWs.mostRecentRequest,
14465           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
14466       assertTrue(GrouperClientWs.mostRecentRequest,
14467           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
14468       assertTrue(GrouperClientWs.mostRecentRequest,
14469           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
14470           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
14471       assertTrue(GrouperClientWs.mostRecentRequest,
14472           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
14473       assertTrue(GrouperClientWs.mostRecentRequest,
14474           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
14475       assertTrue(GrouperClientWs.mostRecentRequest,
14476           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
14477       assertTrue(GrouperClientWs.mostRecentRequest,
14478           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
14479 
14480       // ######################################################
14481       // includeGroupDetail
14482 
14483       baos = new ByteArrayOutputStream();
14484       System.setOut(new PrintStream(baos));
14485 
14486       GrouperClient.main(GrouperClientUtils.splitTrim(
14487           "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=assign_attr " +
14488           "--attributeDefNameNames=test:testAttributeAssignDefName --ownerGroupNames=test:groupTestAttrAssign "
14489           + " --includeGroupDetail=T",
14490           " "));
14491 
14492       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
14493 
14494       System.out.flush();
14495       output = new String(baos.toByteArray());
14496 
14497       System.setOut(systemOut);
14498 
14499       outputLines = GrouperClientUtils.splitTrim(output, "\n");
14500 
14501       outputLine = outputLines[0];
14502 
14503       matcher = pattern.matcher(outputLines[0]);
14504 
14505       assertTrue(outputLine, matcher.matches());
14506       assertEquals(outputLine, "0", matcher.group(1));
14507       assertEquals(outputLine, "group", matcher.group(2));
14508       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
14509       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
14510       assertEquals(outputLine, "assign", matcher.group(5));
14511       assertEquals(outputLine, "3,4,5", matcher.group(6));
14512       assertEquals(outputLine, "T", matcher.group(7));
14513       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
14514       assertEquals(outputLine, "F", matcher.group(9));
14515       assertEquals(outputLine, "F", matcher.group(10));
14516       assertEquals(outputLine, "F", matcher.group(11));
14517 
14518       assertTrue(GrouperClientWs.mostRecentRequest,
14519           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
14520       assertTrue(GrouperClientWs.mostRecentRequest,
14521           !GrouperClientWs.mostRecentRequest.contains("actions"));
14522       assertTrue(GrouperClientWs.mostRecentRequest,
14523           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
14524       assertTrue(GrouperClientWs.mostRecentRequest,
14525           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
14526       assertTrue(GrouperClientWs.mostRecentRequest,
14527           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
14528       assertTrue(GrouperClientWs.mostRecentRequest,
14529           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
14530       assertTrue(GrouperClientWs.mostRecentRequest,
14531           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
14532       assertTrue(GrouperClientWs.mostRecentRequest,
14533           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
14534       assertTrue(GrouperClientWs.mostRecentRequest,
14535           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
14536       assertTrue(GrouperClientWs.mostRecentRequest,
14537           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
14538       assertTrue(GrouperClientWs.mostRecentRequest,
14539           GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
14540       assertTrue(GrouperClientWs.mostRecentRequest,
14541           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
14542       assertTrue(GrouperClientWs.mostRecentRequest,
14543           !GrouperClientWs.mostRecentRequest.contains("params"));
14544       assertTrue(GrouperClientWs.mostRecentRequest,
14545           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
14546       assertTrue(GrouperClientWs.mostRecentRequest,
14547           !GrouperClientWs.mostRecentRequest.contains("values"));
14548       assertTrue(GrouperClientWs.mostRecentRequest,
14549           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
14550       assertTrue(GrouperClientWs.mostRecentRequest,
14551           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
14552           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
14553       assertTrue(GrouperClientWs.mostRecentRequest,
14554           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
14555       assertTrue(GrouperClientWs.mostRecentRequest,
14556           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
14557       assertTrue(GrouperClientWs.mostRecentRequest,
14558           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
14559           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
14560       assertTrue(GrouperClientWs.mostRecentRequest,
14561           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
14562       assertTrue(GrouperClientWs.mostRecentRequest,
14563           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
14564       assertTrue(GrouperClientWs.mostRecentRequest,
14565           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
14566       assertTrue(GrouperClientWs.mostRecentRequest,
14567           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
14568 
14569 
14570       // ######################################################
14571       // includeSubjectDetail
14572 
14573       baos = new ByteArrayOutputStream();
14574       System.setOut(new PrintStream(baos));
14575 
14576       GrouperClient.main(GrouperClientUtils.splitTrim(
14577           "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=assign_attr " +
14578           "--attributeDefNameNames=test:testAttributeAssignDefName --ownerGroupNames=test:groupTestAttrAssign "
14579           + " --includeSubjectDetail=T",
14580           " "));
14581 
14582       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
14583 
14584       System.out.flush();
14585       output = new String(baos.toByteArray());
14586 
14587       System.setOut(systemOut);
14588 
14589       outputLines = GrouperClientUtils.splitTrim(output, "\n");
14590 
14591       outputLine = outputLines[0];
14592 
14593       matcher = pattern.matcher(outputLines[0]);
14594 
14595       assertTrue(outputLine, matcher.matches());
14596       assertEquals(outputLine, "0", matcher.group(1));
14597       assertEquals(outputLine, "group", matcher.group(2));
14598       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
14599       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
14600       assertEquals(outputLine, "assign", matcher.group(5));
14601       assertEquals(outputLine, "3,4,5", matcher.group(6));
14602       assertEquals(outputLine, "T", matcher.group(7));
14603       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
14604       assertEquals(outputLine, "F", matcher.group(9));
14605       assertEquals(outputLine, "F", matcher.group(10));
14606       assertEquals(outputLine, "F", matcher.group(11));
14607 
14608       assertTrue(GrouperClientWs.mostRecentRequest,
14609           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
14610       assertTrue(GrouperClientWs.mostRecentRequest,
14611           !GrouperClientWs.mostRecentRequest.contains("actions"));
14612       assertTrue(GrouperClientWs.mostRecentRequest,
14613           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
14614       assertTrue(GrouperClientWs.mostRecentRequest,
14615           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
14616       assertTrue(GrouperClientWs.mostRecentRequest,
14617           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
14618       assertTrue(GrouperClientWs.mostRecentRequest,
14619           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
14620       assertTrue(GrouperClientWs.mostRecentRequest,
14621           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
14622       assertTrue(GrouperClientWs.mostRecentRequest,
14623           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
14624       assertTrue(GrouperClientWs.mostRecentRequest,
14625           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
14626       assertTrue(GrouperClientWs.mostRecentRequest,
14627           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
14628       assertTrue(GrouperClientWs.mostRecentRequest,
14629           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
14630       assertTrue(GrouperClientWs.mostRecentRequest,
14631           GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
14632       assertTrue(GrouperClientWs.mostRecentRequest,
14633           !GrouperClientWs.mostRecentRequest.contains("params"));
14634       assertTrue(GrouperClientWs.mostRecentRequest,
14635           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
14636       assertTrue(GrouperClientWs.mostRecentRequest,
14637           !GrouperClientWs.mostRecentRequest.contains("values"));
14638       assertTrue(GrouperClientWs.mostRecentRequest,
14639           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
14640       assertTrue(GrouperClientWs.mostRecentRequest,
14641           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
14642           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
14643       assertTrue(GrouperClientWs.mostRecentRequest,
14644           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
14645       assertTrue(GrouperClientWs.mostRecentRequest,
14646           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
14647       assertTrue(GrouperClientWs.mostRecentRequest,
14648           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
14649           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
14650       assertTrue(GrouperClientWs.mostRecentRequest,
14651           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
14652       assertTrue(GrouperClientWs.mostRecentRequest,
14653           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
14654       assertTrue(GrouperClientWs.mostRecentRequest,
14655           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
14656       assertTrue(GrouperClientWs.mostRecentRequest,
14657           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
14658 
14659 
14660       // ######################################################
14661       // subjectAttributeNames
14662 
14663       baos = new ByteArrayOutputStream();
14664       System.setOut(new PrintStream(baos));
14665 
14666       GrouperClient.main(GrouperClientUtils.splitTrim(
14667           "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=assign_attr " +
14668           "--attributeDefNameNames=test:testAttributeAssignDefName --ownerGroupNames=test:groupTestAttrAssign "
14669           + " --subjectAttributeNames=abc",
14670           " "));
14671 
14672       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
14673 
14674       System.out.flush();
14675       output = new String(baos.toByteArray());
14676 
14677       System.setOut(systemOut);
14678 
14679       outputLines = GrouperClientUtils.splitTrim(output, "\n");
14680 
14681       outputLine = outputLines[0];
14682 
14683       matcher = pattern.matcher(outputLines[0]);
14684 
14685       assertTrue(outputLine, matcher.matches());
14686       assertEquals(outputLine, "0", matcher.group(1));
14687       assertEquals(outputLine, "group", matcher.group(2));
14688       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
14689       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
14690       assertEquals(outputLine, "assign", matcher.group(5));
14691       assertEquals(outputLine, "3,4,5", matcher.group(6));
14692       assertEquals(outputLine, "T", matcher.group(7));
14693       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
14694       assertEquals(outputLine, "F", matcher.group(9));
14695       assertEquals(outputLine, "F", matcher.group(10));
14696       assertEquals(outputLine, "F", matcher.group(11));
14697 
14698       assertTrue(GrouperClientWs.mostRecentRequest,
14699           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
14700       assertTrue(GrouperClientWs.mostRecentRequest,
14701           !GrouperClientWs.mostRecentRequest.contains("actions"));
14702       assertTrue(GrouperClientWs.mostRecentRequest,
14703           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
14704       assertTrue(GrouperClientWs.mostRecentRequest,
14705           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
14706       assertTrue(GrouperClientWs.mostRecentRequest,
14707           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
14708       assertTrue(GrouperClientWs.mostRecentRequest,
14709           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
14710       assertTrue(GrouperClientWs.mostRecentRequest,
14711           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
14712       assertTrue(GrouperClientWs.mostRecentRequest,
14713           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
14714       assertTrue(GrouperClientWs.mostRecentRequest,
14715           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
14716       assertTrue(GrouperClientWs.mostRecentRequest,
14717           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
14718       assertTrue(GrouperClientWs.mostRecentRequest,
14719           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
14720       assertTrue(GrouperClientWs.mostRecentRequest,
14721           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
14722       assertTrue(GrouperClientWs.mostRecentRequest,
14723           !GrouperClientWs.mostRecentRequest.contains("params"));
14724       assertTrue(GrouperClientWs.mostRecentRequest,
14725           GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
14726       assertTrue(GrouperClientWs.mostRecentRequest,
14727           !GrouperClientWs.mostRecentRequest.contains("values"));
14728       assertTrue(GrouperClientWs.mostRecentRequest,
14729           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
14730       assertTrue(GrouperClientWs.mostRecentRequest,
14731           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
14732           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
14733       assertTrue(GrouperClientWs.mostRecentRequest,
14734           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
14735       assertTrue(GrouperClientWs.mostRecentRequest,
14736           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
14737       assertTrue(GrouperClientWs.mostRecentRequest,
14738           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
14739           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
14740       assertTrue(GrouperClientWs.mostRecentRequest,
14741           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
14742       assertTrue(GrouperClientWs.mostRecentRequest,
14743           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
14744       assertTrue(GrouperClientWs.mostRecentRequest,
14745           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
14746       assertTrue(GrouperClientWs.mostRecentRequest,
14747           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
14748 
14749 
14750       // ######################################################
14751       // params
14752 
14753       baos = new ByteArrayOutputStream();
14754       System.setOut(new PrintStream(baos));
14755 
14756       GrouperClient.main(GrouperClientUtils.splitTrim(
14757           "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=assign_attr " +
14758           "--attributeDefNameNames=test:testAttributeAssignDefName --ownerGroupNames=test:groupTestAttrAssign "
14759           + " --paramName0=a --paramValue0=b",
14760           " "));
14761 
14762       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
14763 
14764       System.out.flush();
14765       output = new String(baos.toByteArray());
14766 
14767       System.setOut(systemOut);
14768 
14769       outputLines = GrouperClientUtils.splitTrim(output, "\n");
14770 
14771       outputLine = outputLines[0];
14772 
14773       matcher = pattern.matcher(outputLines[0]);
14774 
14775       assertTrue(outputLine, matcher.matches());
14776       assertEquals(outputLine, "0", matcher.group(1));
14777       assertEquals(outputLine, "group", matcher.group(2));
14778       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
14779       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
14780       assertEquals(outputLine, "assign", matcher.group(5));
14781       assertEquals(outputLine, "3,4,5", matcher.group(6));
14782       assertEquals(outputLine, "T", matcher.group(7));
14783       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
14784       assertEquals(outputLine, "F", matcher.group(9));
14785       assertEquals(outputLine, "F", matcher.group(10));
14786       assertEquals(outputLine, "F", matcher.group(11));
14787 
14788       assertTrue(GrouperClientWs.mostRecentRequest,
14789           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
14790       assertTrue(GrouperClientWs.mostRecentRequest,
14791           !GrouperClientWs.mostRecentRequest.contains("actions"));
14792       assertTrue(GrouperClientWs.mostRecentRequest,
14793           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
14794       assertTrue(GrouperClientWs.mostRecentRequest,
14795           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
14796       assertTrue(GrouperClientWs.mostRecentRequest,
14797           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
14798       assertTrue(GrouperClientWs.mostRecentRequest,
14799           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
14800       assertTrue(GrouperClientWs.mostRecentRequest,
14801           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
14802       assertTrue(GrouperClientWs.mostRecentRequest,
14803           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
14804       assertTrue(GrouperClientWs.mostRecentRequest,
14805           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
14806       assertTrue(GrouperClientWs.mostRecentRequest,
14807           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
14808       assertTrue(GrouperClientWs.mostRecentRequest,
14809           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
14810       assertTrue(GrouperClientWs.mostRecentRequest,
14811           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
14812       assertTrue(GrouperClientWs.mostRecentRequest,
14813           GrouperClientWs.mostRecentRequest.contains("params"));
14814       assertTrue(GrouperClientWs.mostRecentRequest,
14815           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
14816       assertTrue(GrouperClientWs.mostRecentRequest,
14817           !GrouperClientWs.mostRecentRequest.contains("values"));
14818       assertTrue(GrouperClientWs.mostRecentRequest,
14819           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
14820       assertTrue(GrouperClientWs.mostRecentRequest,
14821           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
14822           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
14823       assertTrue(GrouperClientWs.mostRecentRequest,
14824           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
14825       assertTrue(GrouperClientWs.mostRecentRequest,
14826           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
14827       assertTrue(GrouperClientWs.mostRecentRequest,
14828           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
14829           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
14830       assertTrue(GrouperClientWs.mostRecentRequest,
14831           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
14832       assertTrue(GrouperClientWs.mostRecentRequest,
14833           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
14834       assertTrue(GrouperClientWs.mostRecentRequest,
14835           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
14836       assertTrue(GrouperClientWs.mostRecentRequest,
14837           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
14838 
14839 
14840       // ######################################################
14841       // attribute assign lookups
14842 
14843       baos = new ByteArrayOutputStream();
14844       System.setOut(new PrintStream(baos));
14845 
14846       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
14847 
14848       String attributeAssignId = attributeAssign.getId();
14849 
14850       GrouperClient.main(GrouperClientUtils.splitTrim(
14851           "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=remove_attr "
14852           + " --attributeAssignUuids=" + attributeAssign.getId(),
14853           " "));
14854 
14855       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, false);
14856 
14857       assertNull("Should be deleted", attributeAssign);
14858 
14859       System.out.flush();
14860       output = new String(baos.toByteArray());
14861 
14862       System.setOut(systemOut);
14863 
14864       outputLines = GrouperClientUtils.splitTrim(output, "\n");
14865 
14866       outputLine = outputLines[0];
14867 
14868       matcher = pattern.matcher(outputLines[0]);
14869 
14870       assertTrue(outputLine, matcher.matches());
14871       assertEquals(outputLine, "0", matcher.group(1));
14872       assertEquals(outputLine, "group", matcher.group(2));
14873       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
14874       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
14875       assertEquals(outputLine, "assign", matcher.group(5));
14876       assertEquals(outputLine, "none", matcher.group(6));
14877       assertEquals(outputLine, "T", matcher.group(7));
14878       assertEquals(outputLine, attributeAssignId, matcher.group(8));
14879       assertEquals(outputLine, "T", matcher.group(9));
14880       assertEquals(outputLine, "T", matcher.group(10));
14881       assertEquals(outputLine, "F", matcher.group(11));
14882 
14883       assertTrue(GrouperClientWs.mostRecentRequest,
14884           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
14885       assertTrue(GrouperClientWs.mostRecentRequest,
14886           !GrouperClientWs.mostRecentRequest.contains("actions"));
14887       assertTrue(GrouperClientWs.mostRecentRequest,
14888           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
14889       assertTrue(GrouperClientWs.mostRecentRequest,
14890           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
14891       assertTrue(GrouperClientWs.mostRecentRequest,
14892           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
14893       assertTrue(GrouperClientWs.mostRecentRequest,
14894           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
14895       assertTrue(GrouperClientWs.mostRecentRequest,
14896           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
14897       assertTrue(GrouperClientWs.mostRecentRequest,
14898           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
14899       assertTrue(GrouperClientWs.mostRecentRequest,
14900           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
14901       assertTrue(GrouperClientWs.mostRecentRequest,
14902           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
14903       assertTrue(GrouperClientWs.mostRecentRequest,
14904           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
14905       assertTrue(GrouperClientWs.mostRecentRequest,
14906           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
14907       assertTrue(GrouperClientWs.mostRecentRequest,
14908           !GrouperClientWs.mostRecentRequest.contains("params"));
14909       assertTrue(GrouperClientWs.mostRecentRequest,
14910           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
14911       assertTrue(GrouperClientWs.mostRecentRequest,
14912           !GrouperClientWs.mostRecentRequest.contains("values"));
14913       assertTrue(GrouperClientWs.mostRecentRequest,
14914           GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
14915       assertTrue(GrouperClientWs.mostRecentRequest,
14916           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
14917           && !GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
14918       assertTrue(GrouperClientWs.mostRecentRequest,
14919           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
14920       assertTrue(GrouperClientWs.mostRecentRequest,
14921           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
14922       assertTrue(GrouperClientWs.mostRecentRequest,
14923           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
14924           && !GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
14925       assertTrue(GrouperClientWs.mostRecentRequest,
14926           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
14927       assertTrue(GrouperClientWs.mostRecentRequest,
14928           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
14929       assertTrue(GrouperClientWs.mostRecentRequest,
14930           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
14931       assertTrue(GrouperClientWs.mostRecentRequest,
14932           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
14933 
14934       // ######################################################
14935       // attribute assign lookups custom tempflate
14936 
14937       baos = new ByteArrayOutputStream();
14938       System.setOut(new PrintStream(baos));
14939 
14940       attributeAssign = group.getAttributeDelegate().assignAttribute(attributeDefName).getAttributeAssign();
14941 
14942       attributeAssignId = attributeAssign.getId();
14943 
14944       GrouperClient.main(GrouperClientUtils.splitTrim(
14945           "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=remove_attr "
14946           + " --attributeAssignUuids=" + attributeAssign.getId() + " --outputTemplate=${wsAttributeAssign.attributeAssignType}$newline$",
14947           " "));
14948 
14949       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, false);
14950 
14951       assertNull("Should be deleted", attributeAssign);
14952 
14953       System.out.flush();
14954       output = new String(baos.toByteArray());
14955 
14956       System.setOut(systemOut);
14957 
14958       outputLines = GrouperClientUtils.splitTrim(output, "\n");
14959 
14960       outputLine = GrouperClientUtils.trim(outputLines[0]);
14961 
14962       assertEquals(outputLine, "group", outputLine);
14963 
14964       assertTrue(GrouperClientWs.mostRecentRequest,
14965           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
14966       assertTrue(GrouperClientWs.mostRecentRequest,
14967           !GrouperClientWs.mostRecentRequest.contains("actions"));
14968       assertTrue(GrouperClientWs.mostRecentRequest,
14969           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
14970       assertTrue(GrouperClientWs.mostRecentRequest,
14971           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
14972       assertTrue(GrouperClientWs.mostRecentRequest,
14973           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
14974       assertTrue(GrouperClientWs.mostRecentRequest,
14975           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
14976       assertTrue(GrouperClientWs.mostRecentRequest,
14977           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
14978       assertTrue(GrouperClientWs.mostRecentRequest,
14979           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
14980       assertTrue(GrouperClientWs.mostRecentRequest,
14981           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
14982       assertTrue(GrouperClientWs.mostRecentRequest,
14983           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
14984       assertTrue(GrouperClientWs.mostRecentRequest,
14985           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
14986       assertTrue(GrouperClientWs.mostRecentRequest,
14987           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
14988       assertTrue(GrouperClientWs.mostRecentRequest,
14989           !GrouperClientWs.mostRecentRequest.contains("params"));
14990       assertTrue(GrouperClientWs.mostRecentRequest,
14991           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
14992       assertTrue(GrouperClientWs.mostRecentRequest,
14993           !GrouperClientWs.mostRecentRequest.contains("values"));
14994       assertTrue(GrouperClientWs.mostRecentRequest,
14995           GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
14996       assertTrue(GrouperClientWs.mostRecentRequest,
14997           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
14998           && !GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
14999       assertTrue(GrouperClientWs.mostRecentRequest,
15000           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
15001       assertTrue(GrouperClientWs.mostRecentRequest,
15002           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
15003       assertTrue(GrouperClientWs.mostRecentRequest,
15004           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
15005           && !GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
15006       assertTrue(GrouperClientWs.mostRecentRequest,
15007           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
15008       assertTrue(GrouperClientWs.mostRecentRequest,
15009           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
15010       assertTrue(GrouperClientWs.mostRecentRequest,
15011           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
15012       assertTrue(GrouperClientWs.mostRecentRequest,
15013           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
15014 
15015 
15016       // ######################################################
15017       // attribute assign lookups
15018 
15019       baos = new ByteArrayOutputStream();
15020       System.setOut(new PrintStream(baos));
15021 
15022       attributeAssign = group.getAttributeDelegate().assignAttribute(attributeDefName).getAttributeAssign();
15023 
15024       attributeAssignId = attributeAssign.getId();
15025 
15026       GrouperClient.main(GrouperClientUtils.splitTrim(
15027           "--operation=assignAttributesWs --attributeAssignType=group --attributeAssignOperation=remove_attr "
15028           + " --attributeAssignUuids=" + attributeAssign.getId() + " --actAsSubjectId=GrouperSystem",
15029           " "));
15030 
15031       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, false);
15032 
15033       assertNull("Should be deleted", attributeAssign);
15034 
15035       System.out.flush();
15036       output = new String(baos.toByteArray());
15037 
15038       System.setOut(systemOut);
15039 
15040       outputLines = GrouperClientUtils.splitTrim(output, "\n");
15041 
15042       outputLine = outputLines[0];
15043 
15044       matcher = pattern.matcher(outputLines[0]);
15045 
15046       assertTrue(outputLine, matcher.matches());
15047       assertEquals(outputLine, "0", matcher.group(1));
15048       assertEquals(outputLine, "group", matcher.group(2));
15049       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
15050       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
15051       assertEquals(outputLine, "assign", matcher.group(5));
15052       assertEquals(outputLine, "none", matcher.group(6));
15053       assertEquals(outputLine, "T", matcher.group(7));
15054       assertEquals(outputLine, attributeAssignId, matcher.group(8));
15055       assertEquals(outputLine, "T", matcher.group(9));
15056       assertEquals(outputLine, "T", matcher.group(10));
15057       assertEquals(outputLine, "F", matcher.group(11));
15058 
15059       assertTrue(GrouperClientWs.mostRecentRequest,
15060           GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
15061       assertTrue(GrouperClientWs.mostRecentRequest,
15062           !GrouperClientWs.mostRecentRequest.contains("actions"));
15063       assertTrue(GrouperClientWs.mostRecentRequest,
15064           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
15065       assertTrue(GrouperClientWs.mostRecentRequest,
15066           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
15067       assertTrue(GrouperClientWs.mostRecentRequest,
15068           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
15069       assertTrue(GrouperClientWs.mostRecentRequest,
15070           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
15071       assertTrue(GrouperClientWs.mostRecentRequest,
15072           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
15073       assertTrue(GrouperClientWs.mostRecentRequest,
15074           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
15075       assertTrue(GrouperClientWs.mostRecentRequest,
15076           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
15077       assertTrue(GrouperClientWs.mostRecentRequest,
15078           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
15079       assertTrue(GrouperClientWs.mostRecentRequest,
15080           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
15081       assertTrue(GrouperClientWs.mostRecentRequest,
15082           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
15083       assertTrue(GrouperClientWs.mostRecentRequest,
15084           !GrouperClientWs.mostRecentRequest.contains("params"));
15085       assertTrue(GrouperClientWs.mostRecentRequest,
15086           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
15087       assertTrue(GrouperClientWs.mostRecentRequest,
15088           !GrouperClientWs.mostRecentRequest.contains("values"));
15089       assertTrue(GrouperClientWs.mostRecentRequest,
15090           GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
15091       assertTrue(GrouperClientWs.mostRecentRequest,
15092           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
15093           && !GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
15094       assertTrue(GrouperClientWs.mostRecentRequest,
15095           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
15096       assertTrue(GrouperClientWs.mostRecentRequest,
15097           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
15098       assertTrue(GrouperClientWs.mostRecentRequest,
15099           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups")
15100           && !GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
15101       assertTrue(GrouperClientWs.mostRecentRequest,
15102           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
15103       assertTrue(GrouperClientWs.mostRecentRequest,
15104           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
15105       assertTrue(GrouperClientWs.mostRecentRequest,
15106           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
15107       assertTrue(GrouperClientWs.mostRecentRequest,
15108           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
15109 
15110 
15111 
15112     } finally {
15113       System.setOut(systemOut);
15114     }
15115 
15116   }
15117 
15118   /**
15119    * @throws Exception
15120    */
15121   public void testAssignAttributesStem() throws Exception {
15122 
15123     AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
15124 
15125     final AttributeDef attributeDef = attributeDefName.getAttributeDef();
15126 
15127     attributeDef.setAssignToGroup(false);
15128     attributeDef.setAssignToStem(true);
15129     attributeDef.store();
15130 
15131     Stem stem = new StemSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
15132       .assignStemNameToEdit("test:stemTestAttrAssign").assignName("test:stemTestAttrAssign").assignCreateParentStemsIfNotExist(true)
15133       .assignDescription("description").save();
15134 
15135 
15136     AttributeAssign attributeAssign = null;
15137     //    AttributeAssignResult attributeAssignResult = group.getAttributeDelegate().assignAttribute(attributeDefName);
15138     //     = attributeAssignResult.getAttributeAssign();
15139 
15140     PrintStream systemOut = System.out;
15141 
15142     ByteArrayOutputStream baos = new ByteArrayOutputStream();
15143     System.setOut(new PrintStream(baos));
15144 
15145     try {
15146 
15147       GrouperClient.main(GrouperClientUtils.splitTrim(
15148           "--operation=assignAttributesWs --attributeAssignType=stem --attributeAssignOperation=assign_attr " +
15149           "--attributeDefNameNames=test:testAttributeAssignDefName --ownerStemNames=test:stemTestAttrAssign",
15150           " "));
15151 
15152       attributeAssign = stem.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
15153 
15154       System.out.flush();
15155       String output = new String(baos.toByteArray());
15156 
15157       System.setOut(systemOut);
15158 
15159       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
15160 
15161       // match: Index: 0: attributeAssignType: group, owner: test:groupTestAttrAssign, attributeDefNameNameName test:testAttributeAssignDefName, action: assign, values: 15,5,5, enable: T, id: a9c83eeb78c04ae5befcea36272d318c, changed: true, valuesChanged: false
15162       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F), changed\: (T|F), valuesChanged\: (T|F)$
15163       Pattern pattern = Pattern
15164         .compile("^Index\\: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName\\: (.+), action\\: (.+), values\\: (.+), enabled\\: (T|F), id\\: (.+), changed\\: (T|F), deleted\\: (T|F), valuesChanged\\: (T|F)$");
15165       String outputLine = outputLines[0];
15166 
15167       Matcher matcher = pattern.matcher(outputLines[0]);
15168 
15169       assertTrue(outputLine, matcher.matches());
15170       assertEquals(outputLine, "0", matcher.group(1));
15171       assertEquals(outputLine, "stem", matcher.group(2));
15172       assertEquals(outputLine, "test:stemTestAttrAssign", matcher.group(3));
15173       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
15174       assertEquals(outputLine, "assign", matcher.group(5));
15175       assertEquals(outputLine, "none", matcher.group(6));
15176       assertEquals(outputLine, "T", matcher.group(7));
15177       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
15178       assertEquals(outputLine, "T", matcher.group(9));
15179       assertEquals(outputLine, "F", matcher.group(10));
15180 
15181       assertTrue(GrouperClientWs.mostRecentRequest,
15182           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
15183       assertTrue(GrouperClientWs.mostRecentRequest,
15184           !GrouperClientWs.mostRecentRequest.contains("actions"));
15185       assertTrue(GrouperClientWs.mostRecentRequest,
15186           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
15187       assertTrue(GrouperClientWs.mostRecentRequest,
15188           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
15189       assertTrue(GrouperClientWs.mostRecentRequest,
15190           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
15191       assertTrue(GrouperClientWs.mostRecentRequest,
15192           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
15193       assertTrue(GrouperClientWs.mostRecentRequest,
15194           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
15195       assertTrue(GrouperClientWs.mostRecentRequest,
15196           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
15197       assertTrue(GrouperClientWs.mostRecentRequest,
15198           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
15199       assertTrue(GrouperClientWs.mostRecentRequest,
15200           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
15201       assertTrue(GrouperClientWs.mostRecentRequest,
15202           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
15203       assertTrue(GrouperClientWs.mostRecentRequest,
15204           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
15205       assertTrue(GrouperClientWs.mostRecentRequest,
15206           !GrouperClientWs.mostRecentRequest.contains("params"));
15207       assertTrue(GrouperClientWs.mostRecentRequest,
15208           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
15209       assertTrue(GrouperClientWs.mostRecentRequest,
15210           !GrouperClientWs.mostRecentRequest.contains("values"));
15211       assertTrue(GrouperClientWs.mostRecentRequest,
15212           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
15213       assertTrue(GrouperClientWs.mostRecentRequest,
15214           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
15215           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
15216       assertTrue(GrouperClientWs.mostRecentRequest,
15217           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
15218       assertTrue(GrouperClientWs.mostRecentRequest,
15219           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
15220       assertTrue(GrouperClientWs.mostRecentRequest,
15221           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
15222       assertTrue(GrouperClientWs.mostRecentRequest,
15223           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
15224       assertTrue(GrouperClientWs.mostRecentRequest,
15225           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
15226       assertTrue(GrouperClientWs.mostRecentRequest,
15227           GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups")
15228           && GrouperClientWs.mostRecentRequest.contains("test:stemTestAttrAssign"));
15229       assertTrue(GrouperClientWs.mostRecentRequest,
15230           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
15231 
15232       // stem uuids
15233       baos = new ByteArrayOutputStream();
15234       System.setOut(new PrintStream(baos));
15235 
15236       GrouperClient.main(GrouperClientUtils.splitTrim(
15237           "--operation=assignAttributesWs --attributeAssignType=stem --attributeAssignOperation=assign_attr " +
15238           "--attributeDefNameUuids=" + attributeDefName.getId() +  " --ownerStemUuids=" + stem.getUuid(),
15239           " "));
15240 
15241       attributeAssign = stem.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
15242 
15243       System.out.flush();
15244       output = new String(baos.toByteArray());
15245 
15246       System.setOut(systemOut);
15247 
15248       outputLines = GrouperClientUtils.splitTrim(output, "\n");
15249 
15250       outputLine = outputLines[0];
15251 
15252       matcher = pattern.matcher(outputLines[0]);
15253 
15254       assertTrue(outputLine, matcher.matches());
15255       assertEquals(outputLine, "0", matcher.group(1));
15256       assertEquals(outputLine, "stem", matcher.group(2));
15257       assertEquals(outputLine, "test:stemTestAttrAssign", matcher.group(3));
15258       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
15259       assertEquals(outputLine, "assign", matcher.group(5));
15260       assertEquals(outputLine, "none", matcher.group(6));
15261       assertEquals(outputLine, "T", matcher.group(7));
15262       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
15263       assertEquals(outputLine, "F", matcher.group(9));
15264       assertEquals(outputLine, "F", matcher.group(10));
15265 
15266       assertTrue(GrouperClientWs.mostRecentRequest,
15267           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
15268       assertTrue(GrouperClientWs.mostRecentRequest,
15269           !GrouperClientWs.mostRecentRequest.contains("actions"));
15270       assertTrue(GrouperClientWs.mostRecentRequest,
15271           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
15272       assertTrue(GrouperClientWs.mostRecentRequest,
15273           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
15274       assertTrue(GrouperClientWs.mostRecentRequest,
15275           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
15276       assertTrue(GrouperClientWs.mostRecentRequest,
15277           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
15278       assertTrue(GrouperClientWs.mostRecentRequest,
15279           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
15280       assertTrue(GrouperClientWs.mostRecentRequest,
15281           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
15282       assertTrue(GrouperClientWs.mostRecentRequest,
15283           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
15284       assertTrue(GrouperClientWs.mostRecentRequest,
15285           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
15286       assertTrue(GrouperClientWs.mostRecentRequest,
15287           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
15288       assertTrue(GrouperClientWs.mostRecentRequest,
15289           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
15290       assertTrue(GrouperClientWs.mostRecentRequest,
15291           !GrouperClientWs.mostRecentRequest.contains("params"));
15292       assertTrue(GrouperClientWs.mostRecentRequest,
15293           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
15294       assertTrue(GrouperClientWs.mostRecentRequest,
15295           !GrouperClientWs.mostRecentRequest.contains("values"));
15296       assertTrue(GrouperClientWs.mostRecentRequest,
15297           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
15298       assertTrue(GrouperClientWs.mostRecentRequest,
15299           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
15300           && GrouperClientWs.mostRecentRequest.contains(stem.getUuid()));
15301       assertTrue(GrouperClientWs.mostRecentRequest,
15302           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
15303       assertTrue(GrouperClientWs.mostRecentRequest,
15304           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
15305       assertTrue(GrouperClientWs.mostRecentRequest,
15306           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
15307       assertTrue(GrouperClientWs.mostRecentRequest,
15308           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
15309       assertTrue(GrouperClientWs.mostRecentRequest,
15310           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
15311       assertTrue(GrouperClientWs.mostRecentRequest,
15312           GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups")
15313           && GrouperClientWs.mostRecentRequest.contains(stem.getUuid()));
15314       assertTrue(GrouperClientWs.mostRecentRequest,
15315           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
15316 
15317 
15318     } finally {
15319       System.setOut(systemOut);
15320     }
15321 
15322   }
15323 
15324   /**
15325    * @throws Exception
15326    */
15327   public void testAssignAttributesMember() throws Exception {
15328 
15329     AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
15330 
15331     final AttributeDef attributeDef = attributeDefName.getAttributeDef();
15332 
15333     attributeDef.setAssignToGroup(false);
15334     attributeDef.setAssignToMember(true);
15335     attributeDef.store();
15336 
15337     GrouperSession grouperSession = GrouperSession.startRootSession();
15338 
15339     Member member = MemberFinder.findBySubject(grouperSession, SubjectTestHelper.SUBJ0, true);
15340 
15341 
15342     AttributeAssign attributeAssign = null;
15343     //    AttributeAssignResult attributeAssignResult = group.getAttributeDelegate().assignAttribute(attributeDefName);
15344     //     = attributeAssignResult.getAttributeAssign();
15345 
15346     PrintStream systemOut = System.out;
15347 
15348     ByteArrayOutputStream baos = new ByteArrayOutputStream();
15349     System.setOut(new PrintStream(baos));
15350 
15351     try {
15352 
15353       GrouperClient.main(GrouperClientUtils.splitTrim(
15354           "--operation=assignAttributesWs --attributeAssignType=member --attributeAssignOperation=assign_attr " +
15355           "--attributeDefNameNames=test:testAttributeAssignDefName --owner0SubjectId=" + SubjectTestHelper.SUBJ0_ID,
15356           " "));
15357 
15358       attributeAssign = member.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
15359 
15360       System.out.flush();
15361       String output = new String(baos.toByteArray());
15362 
15363       System.setOut(systemOut);
15364 
15365       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
15366 
15367       // match: Index: 0: attributeAssignType: group, owner: test:groupTestAttrAssign, attributeDefNameNameName test:testAttributeAssignDefName, action: assign, values: 15,5,5, enable: T, id: a9c83eeb78c04ae5befcea36272d318c, changed: true, valuesChanged: false
15368       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F), changed\: (T|F), valuesChanged\: (T|F)$
15369       Pattern pattern = Pattern
15370         .compile("^Index\\: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName\\: (.+), action\\: (.+), values\\: (.+), enabled\\: (T|F), id\\: (.+), changed\\: (T|F), deleted\\: (T|F), valuesChanged\\: (T|F)$");
15371       String outputLine = outputLines[0];
15372 
15373       Matcher matcher = pattern.matcher(outputLines[0]);
15374 
15375       assertTrue(outputLine, matcher.matches());
15376       assertEquals(outputLine, "0", matcher.group(1));
15377       assertEquals(outputLine, "member", matcher.group(2));
15378       assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(3));
15379       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
15380       assertEquals(outputLine, "assign", matcher.group(5));
15381       assertEquals(outputLine, "none", matcher.group(6));
15382       assertEquals(outputLine, "T", matcher.group(7));
15383       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
15384       assertEquals(outputLine, "T", matcher.group(9));
15385       assertEquals(outputLine, "F", matcher.group(10));
15386 
15387       assertTrue(GrouperClientWs.mostRecentRequest,
15388           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
15389       assertTrue(GrouperClientWs.mostRecentRequest,
15390           !GrouperClientWs.mostRecentRequest.contains("actions"));
15391       assertTrue(GrouperClientWs.mostRecentRequest,
15392           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
15393       assertTrue(GrouperClientWs.mostRecentRequest,
15394           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
15395       assertTrue(GrouperClientWs.mostRecentRequest,
15396           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
15397       assertTrue(GrouperClientWs.mostRecentRequest,
15398           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
15399       assertTrue(GrouperClientWs.mostRecentRequest,
15400           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
15401       assertTrue(GrouperClientWs.mostRecentRequest,
15402           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
15403       assertTrue(GrouperClientWs.mostRecentRequest,
15404           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
15405       assertTrue(GrouperClientWs.mostRecentRequest,
15406           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
15407       assertTrue(GrouperClientWs.mostRecentRequest,
15408           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
15409       assertTrue(GrouperClientWs.mostRecentRequest,
15410           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
15411       assertTrue(GrouperClientWs.mostRecentRequest,
15412           !GrouperClientWs.mostRecentRequest.contains("params"));
15413       assertTrue(GrouperClientWs.mostRecentRequest,
15414           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
15415       assertTrue(GrouperClientWs.mostRecentRequest,
15416           !GrouperClientWs.mostRecentRequest.contains("values"));
15417       assertTrue(GrouperClientWs.mostRecentRequest,
15418           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
15419       assertTrue(GrouperClientWs.mostRecentRequest,
15420           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
15421           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
15422       assertTrue(GrouperClientWs.mostRecentRequest,
15423           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
15424       assertTrue(GrouperClientWs.mostRecentRequest,
15425           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
15426       assertTrue(GrouperClientWs.mostRecentRequest,
15427           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
15428       assertTrue(GrouperClientWs.mostRecentRequest,
15429           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
15430       assertTrue(GrouperClientWs.mostRecentRequest,
15431           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
15432       assertTrue(GrouperClientWs.mostRecentRequest,
15433           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
15434       assertTrue(GrouperClientWs.mostRecentRequest,
15435           GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups")
15436           && GrouperClientWs.mostRecentRequest.contains(SubjectTestHelper.SUBJ0_ID));
15437 
15438       // subject identifier
15439       baos = new ByteArrayOutputStream();
15440       System.setOut(new PrintStream(baos));
15441 
15442       GrouperClient.main(GrouperClientUtils.splitTrim(
15443           "--operation=assignAttributesWs --attributeAssignType=member --attributeAssignOperation=assign_attr " +
15444           "--attributeDefNameUuids=" + attributeDefName.getId() +  " --owner0SubjectIdentifier=id.test.subject.0",
15445           " "));
15446 
15447       attributeAssign = member.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
15448 
15449       System.out.flush();
15450       output = new String(baos.toByteArray());
15451 
15452       System.setOut(systemOut);
15453 
15454       outputLines = GrouperClientUtils.splitTrim(output, "\n");
15455 
15456       outputLine = outputLines[0];
15457 
15458       matcher = pattern.matcher(outputLines[0]);
15459 
15460       assertTrue(outputLine, matcher.matches());
15461       assertEquals(outputLine, "0", matcher.group(1));
15462       assertEquals(outputLine, "member", matcher.group(2));
15463       assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(3));
15464       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
15465       assertEquals(outputLine, "assign", matcher.group(5));
15466       assertEquals(outputLine, "none", matcher.group(6));
15467       assertEquals(outputLine, "T", matcher.group(7));
15468       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
15469       assertEquals(outputLine, "F", matcher.group(9));
15470       assertEquals(outputLine, "F", matcher.group(10));
15471 
15472       assertTrue(GrouperClientWs.mostRecentRequest,
15473           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
15474       assertTrue(GrouperClientWs.mostRecentRequest,
15475           !GrouperClientWs.mostRecentRequest.contains("actions"));
15476       assertTrue(GrouperClientWs.mostRecentRequest,
15477           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
15478       assertTrue(GrouperClientWs.mostRecentRequest,
15479           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
15480       assertTrue(GrouperClientWs.mostRecentRequest,
15481           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
15482       assertTrue(GrouperClientWs.mostRecentRequest,
15483           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
15484       assertTrue(GrouperClientWs.mostRecentRequest,
15485           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
15486       assertTrue(GrouperClientWs.mostRecentRequest,
15487           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
15488       assertTrue(GrouperClientWs.mostRecentRequest,
15489           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
15490       assertTrue(GrouperClientWs.mostRecentRequest,
15491           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
15492       assertTrue(GrouperClientWs.mostRecentRequest,
15493           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
15494       assertTrue(GrouperClientWs.mostRecentRequest,
15495           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
15496       assertTrue(GrouperClientWs.mostRecentRequest,
15497           !GrouperClientWs.mostRecentRequest.contains("params"));
15498       assertTrue(GrouperClientWs.mostRecentRequest,
15499           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
15500       assertTrue(GrouperClientWs.mostRecentRequest,
15501           !GrouperClientWs.mostRecentRequest.contains("values"));
15502       assertTrue(GrouperClientWs.mostRecentRequest,
15503           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
15504       assertTrue(GrouperClientWs.mostRecentRequest,
15505           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
15506           && GrouperClientWs.mostRecentRequest.contains(attributeDefName.getId()));
15507       assertTrue(GrouperClientWs.mostRecentRequest,
15508           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
15509       assertTrue(GrouperClientWs.mostRecentRequest,
15510           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
15511       assertTrue(GrouperClientWs.mostRecentRequest,
15512           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
15513       assertTrue(GrouperClientWs.mostRecentRequest,
15514           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
15515       assertTrue(GrouperClientWs.mostRecentRequest,
15516           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
15517       assertTrue(GrouperClientWs.mostRecentRequest,
15518           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
15519       assertTrue(GrouperClientWs.mostRecentRequest,
15520           GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups")
15521           && GrouperClientWs.mostRecentRequest.contains("id.test.subject.0"));
15522 
15523 
15524     } finally {
15525       System.setOut(systemOut);
15526     }
15527 
15528   }
15529 
15530   /**
15531    * @throws Exception
15532    */
15533   public void testAssignAttributesAttributeDef() throws Exception {
15534 
15535     AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
15536 
15537     final AttributeDef attributeDef = attributeDefName.getAttributeDef();
15538 
15539     attributeDef.setAssignToGroup(false);
15540     attributeDef.setAssignToAttributeDef(true);
15541     attributeDef.store();
15542 
15543     AttributeDef attributeDefAssignTo = AttributeDefTest.exampleAttributeDefDb("test", "testAttributeDefAssignTo");
15544 
15545 
15546     AttributeAssign attributeAssign = null;
15547 
15548     PrintStream systemOut = System.out;
15549 
15550     ByteArrayOutputStream baos = new ByteArrayOutputStream();
15551     System.setOut(new PrintStream(baos));
15552 
15553     try {
15554 
15555       GrouperClient.main(GrouperClientUtils.splitTrim(
15556           "--operation=assignAttributesWs --attributeAssignType=attr_def --attributeAssignOperation=assign_attr " +
15557           "--attributeDefNameNames=test:testAttributeAssignDefName --ownerAttributeDefNames=test:testAttributeDefAssignTo",
15558           " "));
15559 
15560       attributeAssign = attributeDefAssignTo.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
15561 
15562       System.out.flush();
15563       String output = new String(baos.toByteArray());
15564 
15565       System.setOut(systemOut);
15566 
15567       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
15568 
15569       // match: Index: 0: attributeAssignType: group, owner: test:groupTestAttrAssign, attributeDefNameNameName test:testAttributeAssignDefName, action: assign, values: 15,5,5, enable: T, id: a9c83eeb78c04ae5befcea36272d318c, changed: true, valuesChanged: false
15570       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F), changed\: (T|F), valuesChanged\: (T|F)$
15571       Pattern pattern = Pattern
15572           .compile("^Index\\: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName\\: (.+), action\\: (.+), values\\: (.+), enabled\\: (T|F), id\\: (.+), changed\\: (T|F), deleted\\: (T|F), valuesChanged\\: (T|F)$");
15573       String outputLine = outputLines[0];
15574 
15575       Matcher matcher = pattern.matcher(outputLines[0]);
15576 
15577       assertTrue(outputLine, matcher.matches());
15578       assertEquals(outputLine, "0", matcher.group(1));
15579       assertEquals(outputLine, "attr_def", matcher.group(2));
15580       assertEquals(outputLine, attributeDefAssignTo.getName(), matcher.group(3));
15581       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
15582       assertEquals(outputLine, "assign", matcher.group(5));
15583       assertEquals(outputLine, "none", matcher.group(6));
15584       assertEquals(outputLine, "T", matcher.group(7));
15585       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
15586       assertEquals(outputLine, "T", matcher.group(9));
15587       assertEquals(outputLine, "F", matcher.group(10));
15588 
15589       assertTrue(GrouperClientWs.mostRecentRequest,
15590           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
15591       assertTrue(GrouperClientWs.mostRecentRequest,
15592           !GrouperClientWs.mostRecentRequest.contains("actions"));
15593       assertTrue(GrouperClientWs.mostRecentRequest,
15594           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
15595       assertTrue(GrouperClientWs.mostRecentRequest,
15596           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
15597       assertTrue(GrouperClientWs.mostRecentRequest,
15598           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
15599       assertTrue(GrouperClientWs.mostRecentRequest,
15600           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
15601       assertTrue(GrouperClientWs.mostRecentRequest,
15602           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
15603       assertTrue(GrouperClientWs.mostRecentRequest,
15604           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
15605       assertTrue(GrouperClientWs.mostRecentRequest,
15606           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
15607       assertTrue(GrouperClientWs.mostRecentRequest,
15608           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
15609       assertTrue(GrouperClientWs.mostRecentRequest,
15610           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
15611       assertTrue(GrouperClientWs.mostRecentRequest,
15612           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
15613       assertTrue(GrouperClientWs.mostRecentRequest,
15614           !GrouperClientWs.mostRecentRequest.contains("params"));
15615       assertTrue(GrouperClientWs.mostRecentRequest,
15616           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
15617       assertTrue(GrouperClientWs.mostRecentRequest,
15618           !GrouperClientWs.mostRecentRequest.contains("values"));
15619       assertTrue(GrouperClientWs.mostRecentRequest,
15620           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
15621       assertTrue(GrouperClientWs.mostRecentRequest,
15622           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
15623           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
15624       assertTrue(GrouperClientWs.mostRecentRequest,
15625           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
15626       assertTrue(GrouperClientWs.mostRecentRequest,
15627           GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups")
15628           && GrouperClientWs.mostRecentRequest.contains(attributeDefAssignTo.getName()));
15629       assertTrue(GrouperClientWs.mostRecentRequest,
15630           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
15631       assertTrue(GrouperClientWs.mostRecentRequest,
15632           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
15633       assertTrue(GrouperClientWs.mostRecentRequest,
15634           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
15635       assertTrue(GrouperClientWs.mostRecentRequest,
15636           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
15637       assertTrue(GrouperClientWs.mostRecentRequest,
15638           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
15639 
15640       // attribute def uuid
15641       baos = new ByteArrayOutputStream();
15642       System.setOut(new PrintStream(baos));
15643 
15644       GrouperClient.main(GrouperClientUtils.splitTrim(
15645           "--operation=assignAttributesWs --attributeAssignType=attr_def --attributeAssignOperation=assign_attr " +
15646           "--attributeDefNameNames=test:testAttributeAssignDefName --ownerAttributeDefUuids=" + attributeDefAssignTo.getUuid(),
15647           " "));
15648 
15649       attributeAssign = attributeDefAssignTo.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
15650 
15651       System.out.flush();
15652       output = new String(baos.toByteArray());
15653 
15654       System.setOut(systemOut);
15655 
15656       outputLines = GrouperClientUtils.splitTrim(output, "\n");
15657 
15658       outputLine = outputLines[0];
15659 
15660       matcher = pattern.matcher(outputLines[0]);
15661 
15662       assertTrue(outputLine, matcher.matches());
15663       assertEquals(outputLine, "0", matcher.group(1));
15664       assertEquals(outputLine, "attr_def", matcher.group(2));
15665       assertEquals(outputLine, attributeDefAssignTo.getName(), matcher.group(3));
15666       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
15667       assertEquals(outputLine, "assign", matcher.group(5));
15668       assertEquals(outputLine, "none", matcher.group(6));
15669       assertEquals(outputLine, "T", matcher.group(7));
15670       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
15671       assertEquals(outputLine, "F", matcher.group(9));
15672       assertEquals(outputLine, "F", matcher.group(10));
15673 
15674       assertTrue(GrouperClientWs.mostRecentRequest,
15675           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
15676       assertTrue(GrouperClientWs.mostRecentRequest,
15677           !GrouperClientWs.mostRecentRequest.contains("actions"));
15678       assertTrue(GrouperClientWs.mostRecentRequest,
15679           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
15680       assertTrue(GrouperClientWs.mostRecentRequest,
15681           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
15682       assertTrue(GrouperClientWs.mostRecentRequest,
15683           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
15684       assertTrue(GrouperClientWs.mostRecentRequest,
15685           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
15686       assertTrue(GrouperClientWs.mostRecentRequest,
15687           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
15688       assertTrue(GrouperClientWs.mostRecentRequest,
15689           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
15690       assertTrue(GrouperClientWs.mostRecentRequest,
15691           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
15692       assertTrue(GrouperClientWs.mostRecentRequest,
15693           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
15694       assertTrue(GrouperClientWs.mostRecentRequest,
15695           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
15696       assertTrue(GrouperClientWs.mostRecentRequest,
15697           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
15698       assertTrue(GrouperClientWs.mostRecentRequest,
15699           !GrouperClientWs.mostRecentRequest.contains("params"));
15700       assertTrue(GrouperClientWs.mostRecentRequest,
15701           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
15702       assertTrue(GrouperClientWs.mostRecentRequest,
15703           !GrouperClientWs.mostRecentRequest.contains("values"));
15704       assertTrue(GrouperClientWs.mostRecentRequest,
15705           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
15706       assertTrue(GrouperClientWs.mostRecentRequest,
15707           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
15708           && GrouperClientWs.mostRecentRequest.contains(attributeDefAssignTo.getId()));
15709       assertTrue(GrouperClientWs.mostRecentRequest,
15710           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
15711       assertTrue(GrouperClientWs.mostRecentRequest,
15712           GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups")
15713           && GrouperClientWs.mostRecentRequest.contains(attributeDefAssignTo.getUuid()));
15714       assertTrue(GrouperClientWs.mostRecentRequest,
15715           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
15716       assertTrue(GrouperClientWs.mostRecentRequest,
15717           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
15718       assertTrue(GrouperClientWs.mostRecentRequest,
15719           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
15720       assertTrue(GrouperClientWs.mostRecentRequest,
15721           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
15722       assertTrue(GrouperClientWs.mostRecentRequest,
15723           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
15724 
15725       // attribute def uuid
15726       baos = new ByteArrayOutputStream();
15727       System.setOut(new PrintStream(baos));
15728 
15729       GrouperClient.main(GrouperClientUtils.splitTrim(
15730           "--operation=assignAttributesWs --attributeAssignType=attr_def --attributeAssignOperation=assign_attr " +
15731           "--attributeDefNameIdIndexes=" + attributeDefName.getIdIndex() + " --ownerAttributeDefIdIndexes=" + attributeDefAssignTo.getIdIndex(),
15732           " "));
15733 
15734       attributeAssign = attributeDefAssignTo.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
15735 
15736       System.out.flush();
15737       output = new String(baos.toByteArray());
15738 
15739       System.setOut(systemOut);
15740 
15741       outputLines = GrouperClientUtils.splitTrim(output, "\n");
15742 
15743       outputLine = outputLines[0];
15744 
15745       matcher = pattern.matcher(outputLines[0]);
15746 
15747       assertTrue(outputLine, matcher.matches());
15748       assertEquals(outputLine, "0", matcher.group(1));
15749       assertEquals(outputLine, "attr_def", matcher.group(2));
15750       assertEquals(outputLine, attributeDefAssignTo.getName(), matcher.group(3));
15751       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
15752       assertEquals(outputLine, "assign", matcher.group(5));
15753       assertEquals(outputLine, "none", matcher.group(6));
15754       assertEquals(outputLine, "T", matcher.group(7));
15755       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
15756       assertEquals(outputLine, "F", matcher.group(9));
15757       assertEquals(outputLine, "F", matcher.group(10));
15758 
15759       assertTrue(GrouperClientWs.mostRecentRequest,
15760           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
15761       assertTrue(GrouperClientWs.mostRecentRequest,
15762           !GrouperClientWs.mostRecentRequest.contains("actions"));
15763       assertTrue(GrouperClientWs.mostRecentRequest,
15764           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
15765       assertTrue(GrouperClientWs.mostRecentRequest,
15766           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
15767       assertTrue(GrouperClientWs.mostRecentRequest,
15768           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
15769       assertTrue(GrouperClientWs.mostRecentRequest,
15770           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
15771       assertTrue(GrouperClientWs.mostRecentRequest,
15772           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
15773       assertTrue(GrouperClientWs.mostRecentRequest,
15774           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
15775       assertTrue(GrouperClientWs.mostRecentRequest,
15776           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
15777       assertTrue(GrouperClientWs.mostRecentRequest,
15778           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
15779       assertTrue(GrouperClientWs.mostRecentRequest,
15780           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
15781       assertTrue(GrouperClientWs.mostRecentRequest,
15782           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
15783       assertTrue(GrouperClientWs.mostRecentRequest,
15784           !GrouperClientWs.mostRecentRequest.contains("params"));
15785       assertTrue(GrouperClientWs.mostRecentRequest,
15786           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
15787       assertTrue(GrouperClientWs.mostRecentRequest,
15788           !GrouperClientWs.mostRecentRequest.contains("values"));
15789       assertTrue(GrouperClientWs.mostRecentRequest,
15790           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
15791       assertTrue(GrouperClientWs.mostRecentRequest,
15792           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
15793           && GrouperClientWs.mostRecentRequest.contains(attributeDefAssignTo.getIdIndex().toString()));
15794       assertTrue(GrouperClientWs.mostRecentRequest,
15795           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
15796       assertTrue(GrouperClientWs.mostRecentRequest,
15797           GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups")
15798           && GrouperClientWs.mostRecentRequest.contains(attributeDefAssignTo.getIdIndex().toString()));
15799       assertTrue(GrouperClientWs.mostRecentRequest,
15800           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
15801       assertTrue(GrouperClientWs.mostRecentRequest,
15802           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
15803       assertTrue(GrouperClientWs.mostRecentRequest,
15804           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
15805       assertTrue(GrouperClientWs.mostRecentRequest,
15806           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
15807       assertTrue(GrouperClientWs.mostRecentRequest,
15808           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
15809 
15810 
15811     } finally {
15812       System.setOut(systemOut);
15813     }
15814 
15815   }
15816 
15817   /**
15818    * @throws Exception
15819    */
15820   public void testAssignAttributesMembership() throws Exception {
15821 
15822     AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
15823 
15824     final AttributeDef attributeDef = attributeDefName.getAttributeDef();
15825 
15826     attributeDef.setAssignToGroup(false);
15827     attributeDef.setAssignToImmMembership(true);
15828     attributeDef.store();
15829 
15830     Group group1 = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
15831       .assignGroupNameToEdit("test:membershipTestAttrAssign").assignName("test:membershipTestAttrAssign").assignCreateParentStemsIfNotExist(true)
15832       .assignDescription("description").save();
15833 
15834     group1.addMember(SubjectTestHelper.SUBJ0);
15835 
15836     Membership membership = group1.getMemberships(FieldFinder.find("members", true)).iterator().next();
15837 
15838 
15839 
15840     AttributeAssign attributeAssign = null;
15841 
15842     PrintStream systemOut = System.out;
15843 
15844     ByteArrayOutputStream baos = new ByteArrayOutputStream();
15845     System.setOut(new PrintStream(baos));
15846 
15847     try {
15848 
15849       GrouperClient.main(GrouperClientUtils.splitTrim(
15850           "--operation=assignAttributesWs --attributeAssignType=imm_mem --attributeAssignOperation=assign_attr " +
15851           "--attributeDefNameNames=test:testAttributeAssignDefName --ownerMembershipUuids=" + membership.getUuid(),
15852           " "));
15853 
15854       attributeAssign = membership.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
15855 
15856       System.out.flush();
15857       String output = new String(baos.toByteArray());
15858 
15859       System.setOut(systemOut);
15860 
15861       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
15862 
15863       // match: Index: 0: attributeAssignType: group, owner: test:groupTestAttrAssign, attributeDefNameNameName test:testAttributeAssignDefName, action: assign, values: 15,5,5, enable: T, id: a9c83eeb78c04ae5befcea36272d318c, changed: true, valuesChanged: false
15864       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F), changed\: (T|F), valuesChanged\: (T|F)$
15865       Pattern pattern = Pattern
15866         .compile("^Index\\: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName\\: (.+), action\\: (.+), values\\: (.+), enabled\\: (T|F), id\\: (.+), changed\\: (T|F), deleted\\: (T|F), valuesChanged\\: (T|F)$");
15867       String outputLine = outputLines[0];
15868 
15869       Matcher matcher = pattern.matcher(outputLines[0]);
15870 
15871       assertTrue(outputLine, matcher.matches());
15872       assertEquals(outputLine, "0", matcher.group(1));
15873       assertEquals(outputLine, "imm_mem", matcher.group(2));
15874       assertEquals(outputLine, membership.getImmediateMembershipId(), matcher.group(3));
15875       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
15876       assertEquals(outputLine, "assign", matcher.group(5));
15877       assertEquals(outputLine, "none", matcher.group(6));
15878       assertEquals(outputLine, "T", matcher.group(7));
15879       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
15880       assertEquals(outputLine, "T", matcher.group(9));
15881       assertEquals(outputLine, "F", matcher.group(10));
15882 
15883       assertTrue(GrouperClientWs.mostRecentRequest,
15884           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
15885       assertTrue(GrouperClientWs.mostRecentRequest,
15886           !GrouperClientWs.mostRecentRequest.contains("actions"));
15887       assertTrue(GrouperClientWs.mostRecentRequest,
15888           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
15889       assertTrue(GrouperClientWs.mostRecentRequest,
15890           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
15891       assertTrue(GrouperClientWs.mostRecentRequest,
15892           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
15893       assertTrue(GrouperClientWs.mostRecentRequest,
15894           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
15895       assertTrue(GrouperClientWs.mostRecentRequest,
15896           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
15897       assertTrue(GrouperClientWs.mostRecentRequest,
15898           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
15899       assertTrue(GrouperClientWs.mostRecentRequest,
15900           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
15901       assertTrue(GrouperClientWs.mostRecentRequest,
15902           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
15903       assertTrue(GrouperClientWs.mostRecentRequest,
15904           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
15905       assertTrue(GrouperClientWs.mostRecentRequest,
15906           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
15907       assertTrue(GrouperClientWs.mostRecentRequest,
15908           !GrouperClientWs.mostRecentRequest.contains("params"));
15909       assertTrue(GrouperClientWs.mostRecentRequest,
15910           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
15911       assertTrue(GrouperClientWs.mostRecentRequest,
15912           !GrouperClientWs.mostRecentRequest.contains("values"));
15913       assertTrue(GrouperClientWs.mostRecentRequest,
15914           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
15915       assertTrue(GrouperClientWs.mostRecentRequest,
15916           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
15917           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
15918       assertTrue(GrouperClientWs.mostRecentRequest,
15919           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
15920       assertTrue(GrouperClientWs.mostRecentRequest,
15921           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
15922       assertTrue(GrouperClientWs.mostRecentRequest,
15923           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
15924       assertTrue(GrouperClientWs.mostRecentRequest,
15925           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
15926       assertTrue(GrouperClientWs.mostRecentRequest,
15927           GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups")
15928           && GrouperClientWs.mostRecentRequest.contains(membership.getUuid()));
15929       assertTrue(GrouperClientWs.mostRecentRequest,
15930           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
15931       assertTrue(GrouperClientWs.mostRecentRequest,
15932           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
15933 
15934 
15935     } finally {
15936       System.setOut(systemOut);
15937     }
15938 
15939   }
15940 
15941   /**
15942    * @throws Exception
15943    */
15944   public void testAssignAttributesAnyMembership() throws Exception {
15945 
15946     GrouperSession grouperSession = GrouperSession.startRootSession();
15947 
15948     AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
15949 
15950     final AttributeDef attributeDef = attributeDefName.getAttributeDef();
15951 
15952     attributeDef.setAssignToGroup(false);
15953     attributeDef.setAssignToEffMembership(true);
15954     attributeDef.store();
15955 
15956     Group group1 = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
15957       .assignGroupNameToEdit("test:anyMembershipTestAttrAssign").assignName("test:anyMembershipTestAttrAssign").assignCreateParentStemsIfNotExist(true)
15958       .assignDescription("description").save();
15959 
15960     Group group2 = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
15961       .assignGroupNameToEdit("test:anyMembershipTestAttrAssign2").assignName("test:anyMembershipTestAttrAssign2").assignCreateParentStemsIfNotExist(true)
15962       .assignDescription("description").save();
15963 
15964     //add one group to another to make effective membership and add attribute to that membership
15965     group1.addMember(group2.toSubject());
15966     group2.addMember(SubjectTestHelper.SUBJ0);
15967 
15968     Member member = MemberFinder.findBySubject(grouperSession, SubjectTestHelper.SUBJ0, false);
15969 
15970     Membership membership = (Membership)MembershipFinder.findMemberships(GrouperUtil.toSet(group1.getId()),
15971         GrouperUtil.toSet(member.getUuid()), null, null, FieldFinder.find("members", true), null, null, null, null, null).iterator().next()[0];
15972 
15973 
15974     AttributeAssign attributeAssign = null;
15975 
15976     PrintStream systemOut = System.out;
15977 
15978     ByteArrayOutputStream baos = new ByteArrayOutputStream();
15979     System.setOut(new PrintStream(baos));
15980 
15981     try {
15982 
15983       GrouperClient.main(GrouperClientUtils.splitTrim(
15984           "--operation=assignAttributesWs --attributeAssignType=any_mem --attributeAssignOperation=assign_attr " +
15985           "--attributeDefNameNames=test:testAttributeAssignDefName --ownerMembershipAny0SubjectId=" + member.getSubjectId()
15986           + " --ownerMembershipAny0GroupName=" + group1.getName(),
15987           " "));
15988 
15989       attributeAssign = membership.getAttributeDelegateEffMship().retrieveAssignment("assign", attributeDefName, false, true);
15990 
15991       System.out.flush();
15992       String output = new String(baos.toByteArray());
15993 
15994       System.setOut(systemOut);
15995 
15996       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
15997 
15998       // match: Index: 0: attributeAssignType: group, owner: test:groupTestAttrAssign, attributeDefNameNameName test:testAttributeAssignDefName, action: assign, values: 15,5,5, enable: T, id: a9c83eeb78c04ae5befcea36272d318c, changed: true, valuesChanged: false
15999       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F), changed\: (T|F), valuesChanged\: (T|F)$
16000       Pattern pattern = Pattern
16001         .compile("^Index\\: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName\\: (.+), action\\: (.+), values\\: (.+), enabled\\: (T|F), id\\: (.+), changed\\: (T|F), deleted\\: (T|F), valuesChanged\\: (T|F)$");
16002       String outputLine = outputLines[0];
16003 
16004       Matcher matcher = pattern.matcher(outputLines[0]);
16005 
16006       assertTrue(outputLine, matcher.matches());
16007       assertEquals(outputLine, "0", matcher.group(1));
16008       assertEquals(outputLine, "any_mem", matcher.group(2));
16009       assertEquals(outputLine, "test:anyMembershipTestAttrAssign - jdbc - test.subject.0", matcher.group(3));
16010       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
16011       assertEquals(outputLine, "assign", matcher.group(5));
16012       assertEquals(outputLine, "none", matcher.group(6));
16013       assertEquals(outputLine, "T", matcher.group(7));
16014       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
16015       assertEquals(outputLine, "T", matcher.group(9));
16016       assertEquals(outputLine, "F", matcher.group(10));
16017 
16018       assertTrue(GrouperClientWs.mostRecentRequest,
16019           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
16020       assertTrue(GrouperClientWs.mostRecentRequest,
16021           !GrouperClientWs.mostRecentRequest.contains("actions"));
16022       assertTrue(GrouperClientWs.mostRecentRequest,
16023           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
16024       assertTrue(GrouperClientWs.mostRecentRequest,
16025           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
16026       assertTrue(GrouperClientWs.mostRecentRequest,
16027           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
16028       assertTrue(GrouperClientWs.mostRecentRequest,
16029           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
16030       assertTrue(GrouperClientWs.mostRecentRequest,
16031           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
16032       assertTrue(GrouperClientWs.mostRecentRequest,
16033           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
16034       assertTrue(GrouperClientWs.mostRecentRequest,
16035           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
16036       assertTrue(GrouperClientWs.mostRecentRequest,
16037           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
16038       assertTrue(GrouperClientWs.mostRecentRequest,
16039           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
16040       assertTrue(GrouperClientWs.mostRecentRequest,
16041           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
16042       assertTrue(GrouperClientWs.mostRecentRequest,
16043           !GrouperClientWs.mostRecentRequest.contains("params"));
16044       assertTrue(GrouperClientWs.mostRecentRequest,
16045           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
16046       assertTrue(GrouperClientWs.mostRecentRequest,
16047           !GrouperClientWs.mostRecentRequest.contains("values"));
16048       assertTrue(GrouperClientWs.mostRecentRequest,
16049           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
16050       assertTrue(GrouperClientWs.mostRecentRequest,
16051           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups")
16052           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
16053       assertTrue(GrouperClientWs.mostRecentRequest,
16054           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups"));
16055       assertTrue(GrouperClientWs.mostRecentRequest,
16056           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
16057       assertTrue(GrouperClientWs.mostRecentRequest,
16058           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
16059       assertTrue(GrouperClientWs.mostRecentRequest,
16060           GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups")
16061           && GrouperClientWs.mostRecentRequest.contains(group1.getName())
16062           && GrouperClientWs.mostRecentRequest.contains(member.getSubjectId()));
16063       assertTrue(GrouperClientWs.mostRecentRequest,
16064           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
16065       assertTrue(GrouperClientWs.mostRecentRequest,
16066           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
16067       assertTrue(GrouperClientWs.mostRecentRequest,
16068           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
16069 
16070 
16071     } finally {
16072       System.setOut(systemOut);
16073     }
16074 
16075   }
16076 
16077   /**
16078    * @throws Exception
16079    */
16080   public void testAssignAttributesMembershipAssn() throws Exception {
16081 
16082     AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
16083 
16084     final AttributeDef attributeDef = attributeDefName.getAttributeDef();
16085 
16086     attributeDef.setAssignToGroup(false);
16087     attributeDef.setAssignToImmMembership(true);
16088     attributeDef.store();
16089 
16090     AttributeDefName attributeDefName2 = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName2");
16091 
16092     final AttributeDef attributeDef2 = attributeDefName2.getAttributeDef();
16093 
16094     attributeDef2.setAssignToGroup(false);
16095     attributeDef2.setAssignToImmMembershipAssn(true);
16096     attributeDef2.store();
16097 
16098     Group group1 = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
16099       .assignGroupNameToEdit("test:membershipTestAttrAssign").assignName("test:membershipTestAttrAssign").assignCreateParentStemsIfNotExist(true)
16100       .assignDescription("description").save();
16101 
16102     group1.addMember(SubjectTestHelper.SUBJ0);
16103 
16104     Membership membership = group1.getMemberships(FieldFinder.find("members", true)).iterator().next();
16105 
16106     AttributeAssign attributeAssign = membership.getAttributeDelegate().assignAttribute(attributeDefName).getAttributeAssign();
16107 
16108     //we need to wait some seconds for the cache to clear
16109     GrouperUtil.sleep(20000);
16110 
16111     PrintStream systemOut = System.out;
16112 
16113     ByteArrayOutputStream baos = new ByteArrayOutputStream();
16114     System.setOut(new PrintStream(baos));
16115 
16116     try {
16117 
16118       GrouperClient.main(GrouperClientUtils.splitTrim(
16119           "--operation=assignAttributesWs --attributeAssignType=imm_mem_asgn --attributeAssignOperation=assign_attr " +
16120           "--attributeDefNameNames=test:testAttributeAssignDefName2 --ownerAttributeAssignUuids=" + attributeAssign.getId(),
16121           " "));
16122 
16123       AttributeAssign attributeAssign2 = attributeAssign.getAttributeDelegate().retrieveAssignment("assign", attributeDefName2, false, true);
16124 
16125       System.out.flush();
16126       String output = new String(baos.toByteArray());
16127 
16128       System.setOut(systemOut);
16129 
16130       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
16131 
16132       // match: Index: 0: attributeAssignType: group, owner: test:groupTestAttrAssign, attributeDefNameNameName test:testAttributeAssignDefName, action: assign, values: 15,5,5, enable: T, id: a9c83eeb78c04ae5befcea36272d318c, changed: true, valuesChanged: false
16133       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F), changed\: (T|F), valuesChanged\: (T|F)$
16134       Pattern pattern = Pattern
16135         .compile("^Index\\: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName\\: (.+), action\\: (.+), values\\: (.+), enabled\\: (T|F), id\\: (.+), changed\\: (T|F), deleted\\: (T|F), valuesChanged\\: (T|F)$");
16136       String outputLine = outputLines[0];
16137 
16138       Matcher matcher = pattern.matcher(outputLines[0]);
16139 
16140       assertTrue(outputLine, matcher.matches());
16141       assertEquals(outputLine, "0", matcher.group(1));
16142       assertEquals(outputLine, "imm_mem_asgn", matcher.group(2));
16143       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
16144       assertEquals(outputLine, "test:testAttributeAssignDefName2", matcher.group(4));
16145       assertEquals(outputLine, "assign", matcher.group(5));
16146       assertEquals(outputLine, "none", matcher.group(6));
16147       assertEquals(outputLine, "T", matcher.group(7));
16148       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
16149       assertEquals(outputLine, "T", matcher.group(9));
16150       assertEquals(outputLine, "F", matcher.group(10));
16151 
16152       assertTrue(GrouperClientWs.mostRecentRequest,
16153           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
16154       assertTrue(GrouperClientWs.mostRecentRequest,
16155           !GrouperClientWs.mostRecentRequest.contains("actions"));
16156       assertTrue(GrouperClientWs.mostRecentRequest,
16157           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
16158       assertTrue(GrouperClientWs.mostRecentRequest,
16159           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
16160       assertTrue(GrouperClientWs.mostRecentRequest,
16161           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
16162       assertTrue(GrouperClientWs.mostRecentRequest,
16163           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
16164       assertTrue(GrouperClientWs.mostRecentRequest,
16165           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
16166       assertTrue(GrouperClientWs.mostRecentRequest,
16167           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
16168       assertTrue(GrouperClientWs.mostRecentRequest,
16169           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
16170       assertTrue(GrouperClientWs.mostRecentRequest,
16171           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
16172       assertTrue(GrouperClientWs.mostRecentRequest,
16173           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
16174       assertTrue(GrouperClientWs.mostRecentRequest,
16175           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
16176       assertTrue(GrouperClientWs.mostRecentRequest,
16177           !GrouperClientWs.mostRecentRequest.contains("params"));
16178       assertTrue(GrouperClientWs.mostRecentRequest,
16179           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
16180       assertTrue(GrouperClientWs.mostRecentRequest,
16181           !GrouperClientWs.mostRecentRequest.contains("values"));
16182       assertTrue(GrouperClientWs.mostRecentRequest,
16183           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
16184       assertTrue(GrouperClientWs.mostRecentRequest,
16185           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
16186       assertTrue(GrouperClientWs.mostRecentRequest,
16187           GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookups")
16188           && GrouperClientWs.mostRecentRequest.contains(attributeAssign.getId()));
16189       assertTrue(GrouperClientWs.mostRecentRequest,
16190           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
16191       assertTrue(GrouperClientWs.mostRecentRequest,
16192           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
16193       assertTrue(GrouperClientWs.mostRecentRequest,
16194           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
16195       assertTrue(GrouperClientWs.mostRecentRequest,
16196           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
16197       assertTrue(GrouperClientWs.mostRecentRequest,
16198           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
16199       assertTrue(GrouperClientWs.mostRecentRequest,
16200           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
16201 
16202 
16203     } finally {
16204       System.setOut(systemOut);
16205     }
16206 
16207   }
16208 
16209   /**
16210      * @throws Exception
16211      */
16212     public void testGetPermissionAssigns() throws Exception {
16213 
16214       GrouperSession grouperSession = GrouperSession.startRootSession();
16215 
16216       Stem aStem = Stem.saveStem(grouperSession, "aStem", null,"aStem", "a stem",  "a stem description", null, false);
16217 
16218       //parent implies child
16219       Role role = aStem.addChildRole("role", "role");
16220       Role role2 = aStem.addChildRole("role2", "role2");
16221 
16222       ((Group)role).addMember(SubjectTestHelper.SUBJ0);
16223       ((Group)role2).addMember(SubjectTestHelper.SUBJ1);
16224 
16225       AttributeDef permissionDef = aStem.addChildAttributeDef("permissionDef", AttributeDefType.perm);
16226       permissionDef.setAssignToEffMembership(true);
16227       permissionDef.setAssignToGroup(true);
16228       permissionDef.store();
16229       AttributeDefName permissionDefName = aStem.addChildAttributeDefName(permissionDef, "permissionDefName", "permissionDefName");
16230       AttributeDefName permissionDefName2 = aStem.addChildAttributeDefName(permissionDef, "permissionDefName2", "permissionDefName2");
16231 
16232       permissionDef.getAttributeDefActionDelegate().addAction("action");
16233       permissionDef.getAttributeDefActionDelegate().addAction("action2");
16234 
16235       //subject 0 has a "role" permission of permissionDefName with "action" in
16236       //subject 1 has a "role_subject" permission of permissionDefName2 with action2
16237 
16238       role.getPermissionRoleDelegate().assignRolePermission("action", permissionDefName);
16239       role2.getPermissionRoleDelegate()
16240         .assignSubjectRolePermission("action2", permissionDefName2, SubjectTestHelper.SUBJ1);
16241 
16242       PrintStream systemOut = System.out;
16243 
16244       ByteArrayOutputStream baos = new ByteArrayOutputStream();
16245       System.setOut(new PrintStream(baos));
16246 
16247       try {
16248 
16249         GrouperClient.main(GrouperClientUtils.splitTrim(
16250             "--operation=getPermissionAssignmentsWs --attributeDefNames=aStem:permissionDef",
16251             " "));
16252         System.out.flush();
16253         String output = new String(baos.toByteArray());
16254 
16255         System.setOut(systemOut);
16256 
16257         String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
16258 
16259         // match: Index: 0: permissionType: role, role: aStem:role, subject: jdbc - test.subject.0, attributeDefNameName: aStem:permissionDefName, action: action, allowedOverall: T, enabled: T
16260         // match: ^Index: (\d+)\: permissionType\: (.+), role\: (.+), subject\: (.+), attributeDefNameName\: (.+), action\: (.+), allowedOverall: (T|F), enabled\: (T|F)
16261         Pattern pattern = Pattern
16262             .compile("^Index: (\\d+)\\: permissionType\\: (.+), role\\: (.+), subject\\: (.+), attributeDefNameName: (.+), action\\: (.+), allowedOverall\\: (.+), enabled\\: (T|F)$");
16263 
16264         assertEquals(2, outputLines.length);
16265         String outputLine = outputLines[0];
16266 
16267         Matcher matcher = pattern.matcher(outputLines[0]);
16268 
16269         assertTrue(outputLine, matcher.matches());
16270         assertEquals(outputLine, "0", matcher.group(1));
16271         assertEquals(outputLine, "role", matcher.group(2));
16272         assertEquals(outputLine, "aStem:role", matcher.group(3));
16273         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
16274         assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
16275         assertEquals(outputLine, "action", matcher.group(6));
16276         assertEquals(outputLine, "T", matcher.group(7));
16277         assertEquals(outputLine, "T", matcher.group(8));
16278 
16279         outputLine = outputLines[1];
16280 
16281         matcher = pattern.matcher(outputLines[1]);
16282 
16283         assertTrue(outputLine, matcher.matches());
16284         assertEquals(outputLine, "1", matcher.group(1));
16285         assertEquals(outputLine, "role_subject", matcher.group(2));
16286         assertEquals(outputLine, "aStem:role2", matcher.group(3));
16287         assertEquals(outputLine, "jdbc - test.subject.1", matcher.group(4));
16288         assertEquals(outputLine, "aStem:permissionDefName2", matcher.group(5));
16289         assertEquals(outputLine, "action2", matcher.group(6));
16290         assertEquals(outputLine, "T", matcher.group(7));
16291         assertEquals(outputLine, "T", matcher.group(8));
16292 
16293         assertTrue(GrouperClientWs.mostRecentRequest,
16294             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
16295         assertTrue(GrouperClientWs.mostRecentRequest,
16296             !GrouperClientWs.mostRecentRequest.contains("actions"));
16297         assertTrue(GrouperClientWs.mostRecentRequest,
16298             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
16299         assertTrue(GrouperClientWs.mostRecentRequest,
16300             !GrouperClientWs.mostRecentRequest.contains("enabled"));
16301         assertTrue(GrouperClientWs.mostRecentRequest,
16302             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
16303         assertTrue(GrouperClientWs.mostRecentRequest,
16304             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
16305         assertTrue(GrouperClientWs.mostRecentRequest,
16306             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
16307         assertTrue(GrouperClientWs.mostRecentRequest,
16308             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
16309         assertTrue(GrouperClientWs.mostRecentRequest,
16310             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
16311         assertTrue(GrouperClientWs.mostRecentRequest,
16312             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
16313         assertTrue(GrouperClientWs.mostRecentRequest,
16314             !GrouperClientWs.mostRecentRequest.contains("params"));
16315         assertTrue(GrouperClientWs.mostRecentRequest,
16316             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
16317         assertTrue(GrouperClientWs.mostRecentRequest,
16318             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
16319         assertTrue(GrouperClientWs.mostRecentRequest,
16320             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
16321         assertTrue(GrouperClientWs.mostRecentRequest,
16322             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
16323         assertTrue(GrouperClientWs.mostRecentRequest,
16324             !GrouperClientWs.mostRecentRequest.contains("roleLookups"));
16325         assertTrue(GrouperClientWs.mostRecentRequest,
16326             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
16327 
16328 
16329 
16330 
16331         // ######################################################
16332         // Try attributeDefId
16333 
16334         baos = new ByteArrayOutputStream();
16335         System.setOut(new PrintStream(baos));
16336 
16337         GrouperClient.main(GrouperClientUtils.splitTrim(
16338             "--operation=getPermissionAssignmentsWs --attributeDefUuids=" + permissionDef.getId(),
16339             " "));
16340 
16341 
16342         System.out.flush();
16343         output = new String(baos.toByteArray());
16344 
16345         outputLines = GrouperClientUtils.splitTrim(output, "\n");
16346 
16347         System.setOut(systemOut);
16348 
16349 
16350         assertEquals(2, outputLines.length);
16351         outputLine = outputLines[0];
16352 
16353         matcher = pattern.matcher(outputLines[0]);
16354 
16355         assertTrue(outputLine, matcher.matches());
16356         assertEquals(outputLine, "0", matcher.group(1));
16357         assertEquals(outputLine, "role", matcher.group(2));
16358         assertEquals(outputLine, "aStem:role", matcher.group(3));
16359         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
16360         assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
16361         assertEquals(outputLine, "action", matcher.group(6));
16362         assertEquals(outputLine, "T", matcher.group(7));
16363         assertEquals(outputLine, "T", matcher.group(8));
16364 
16365         outputLine = outputLines[1];
16366 
16367         matcher = pattern.matcher(outputLines[1]);
16368 
16369         assertTrue(outputLine, matcher.matches());
16370         assertEquals(outputLine, "1", matcher.group(1));
16371         assertEquals(outputLine, "role_subject", matcher.group(2));
16372         assertEquals(outputLine, "aStem:role2", matcher.group(3));
16373         assertEquals(outputLine, "jdbc - test.subject.1", matcher.group(4));
16374         assertEquals(outputLine, "aStem:permissionDefName2", matcher.group(5));
16375         assertEquals(outputLine, "action2", matcher.group(6));
16376         assertEquals(outputLine, "T", matcher.group(7));
16377         assertEquals(outputLine, "T", matcher.group(8));
16378 
16379         assertTrue(GrouperClientWs.mostRecentRequest,
16380             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
16381         assertTrue(GrouperClientWs.mostRecentRequest,
16382             !GrouperClientWs.mostRecentRequest.contains("actions"));
16383         assertTrue(GrouperClientWs.mostRecentRequest,
16384             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
16385         assertTrue(GrouperClientWs.mostRecentRequest,
16386             !GrouperClientWs.mostRecentRequest.contains("enabled"));
16387         assertTrue(GrouperClientWs.mostRecentRequest,
16388             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
16389         assertTrue(GrouperClientWs.mostRecentRequest,
16390             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
16391         assertTrue(GrouperClientWs.mostRecentRequest,
16392             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
16393         assertTrue(GrouperClientWs.mostRecentRequest,
16394             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
16395         assertTrue(GrouperClientWs.mostRecentRequest,
16396             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
16397         assertTrue(GrouperClientWs.mostRecentRequest,
16398             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
16399         assertTrue(GrouperClientWs.mostRecentRequest,
16400             !GrouperClientWs.mostRecentRequest.contains("params"));
16401         assertTrue(GrouperClientWs.mostRecentRequest,
16402             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
16403         assertTrue(GrouperClientWs.mostRecentRequest,
16404             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
16405         assertTrue(GrouperClientWs.mostRecentRequest,
16406             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
16407         assertTrue(GrouperClientWs.mostRecentRequest,
16408             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
16409         assertTrue(GrouperClientWs.mostRecentRequest,
16410             !GrouperClientWs.mostRecentRequest.contains("roleLookups"));
16411         assertTrue(GrouperClientWs.mostRecentRequest,
16412             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
16413 
16414         // ######################################################
16415         // Try attributeDefIdIndex
16416 
16417         baos = new ByteArrayOutputStream();
16418         System.setOut(new PrintStream(baos));
16419 
16420         GrouperClient.main(GrouperClientUtils.splitTrim(
16421             "--operation=getPermissionAssignmentsWs --attributeDefIdIndexes=" + permissionDef.getIdIndex(),
16422             " "));
16423 
16424 
16425         System.out.flush();
16426         output = new String(baos.toByteArray());
16427 
16428         outputLines = GrouperClientUtils.splitTrim(output, "\n");
16429 
16430         System.setOut(systemOut);
16431 
16432 
16433         assertEquals(2, outputLines.length);
16434         outputLine = outputLines[0];
16435 
16436         matcher = pattern.matcher(outputLines[0]);
16437 
16438         assertTrue(outputLine, matcher.matches());
16439         assertEquals(outputLine, "0", matcher.group(1));
16440         assertEquals(outputLine, "role", matcher.group(2));
16441         assertEquals(outputLine, "aStem:role", matcher.group(3));
16442         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
16443         assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
16444         assertEquals(outputLine, "action", matcher.group(6));
16445         assertEquals(outputLine, "T", matcher.group(7));
16446         assertEquals(outputLine, "T", matcher.group(8));
16447 
16448         outputLine = outputLines[1];
16449 
16450         matcher = pattern.matcher(outputLines[1]);
16451 
16452         assertTrue(outputLine, matcher.matches());
16453         assertEquals(outputLine, "1", matcher.group(1));
16454         assertEquals(outputLine, "role_subject", matcher.group(2));
16455         assertEquals(outputLine, "aStem:role2", matcher.group(3));
16456         assertEquals(outputLine, "jdbc - test.subject.1", matcher.group(4));
16457         assertEquals(outputLine, "aStem:permissionDefName2", matcher.group(5));
16458         assertEquals(outputLine, "action2", matcher.group(6));
16459         assertEquals(outputLine, "T", matcher.group(7));
16460         assertEquals(outputLine, "T", matcher.group(8));
16461 
16462         assertTrue(GrouperClientWs.mostRecentRequest,
16463             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
16464         assertTrue(GrouperClientWs.mostRecentRequest,
16465             !GrouperClientWs.mostRecentRequest.contains("actions"));
16466         assertTrue(GrouperClientWs.mostRecentRequest,
16467             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
16468         assertTrue(GrouperClientWs.mostRecentRequest,
16469             !GrouperClientWs.mostRecentRequest.contains("enabled"));
16470         assertTrue(GrouperClientWs.mostRecentRequest,
16471             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
16472         assertTrue(GrouperClientWs.mostRecentRequest,
16473             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
16474         assertTrue(GrouperClientWs.mostRecentRequest,
16475             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
16476         assertTrue(GrouperClientWs.mostRecentRequest,
16477             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
16478         assertTrue(GrouperClientWs.mostRecentRequest,
16479             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
16480         assertTrue(GrouperClientWs.mostRecentRequest,
16481             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
16482         assertTrue(GrouperClientWs.mostRecentRequest,
16483             !GrouperClientWs.mostRecentRequest.contains("params"));
16484         assertTrue(GrouperClientWs.mostRecentRequest,
16485             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
16486         assertTrue(GrouperClientWs.mostRecentRequest,
16487             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
16488         assertTrue(GrouperClientWs.mostRecentRequest,
16489             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<idIndex>"));
16490         assertTrue(GrouperClientWs.mostRecentRequest,
16491             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
16492         assertTrue(GrouperClientWs.mostRecentRequest,
16493             !GrouperClientWs.mostRecentRequest.contains("roleLookups"));
16494         assertTrue(GrouperClientWs.mostRecentRequest,
16495             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
16496 
16497 
16498 
16499         // ######################################################
16500         // Try attributeDefNameName
16501 
16502         baos = new ByteArrayOutputStream();
16503         System.setOut(new PrintStream(baos));
16504 
16505         GrouperClient.main(GrouperClientUtils.splitTrim(
16506             "--operation=getPermissionAssignmentsWs --attributeDefNameNames=" + permissionDefName.getName(),
16507             " "));
16508 
16509 
16510         System.out.flush();
16511         output = new String(baos.toByteArray());
16512 
16513         outputLines = GrouperClientUtils.splitTrim(output, "\n");
16514 
16515         System.setOut(systemOut);
16516 
16517 
16518         assertEquals(1, outputLines.length);
16519         outputLine = outputLines[0];
16520 
16521         matcher = pattern.matcher(outputLines[0]);
16522 
16523         assertTrue(outputLine, matcher.matches());
16524         assertEquals(outputLine, "0", matcher.group(1));
16525         assertEquals(outputLine, "role", matcher.group(2));
16526         assertEquals(outputLine, "aStem:role", matcher.group(3));
16527         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
16528         assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
16529         assertEquals(outputLine, "action", matcher.group(6));
16530         assertEquals(outputLine, "T", matcher.group(7));
16531         assertEquals(outputLine, "T", matcher.group(8));
16532 
16533         assertTrue(GrouperClientWs.mostRecentRequest,
16534             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
16535         assertTrue(GrouperClientWs.mostRecentRequest,
16536             !GrouperClientWs.mostRecentRequest.contains("actions"));
16537         assertTrue(GrouperClientWs.mostRecentRequest,
16538             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
16539         assertTrue(GrouperClientWs.mostRecentRequest,
16540             !GrouperClientWs.mostRecentRequest.contains("enabled"));
16541         assertTrue(GrouperClientWs.mostRecentRequest,
16542             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
16543         assertTrue(GrouperClientWs.mostRecentRequest,
16544             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
16545         assertTrue(GrouperClientWs.mostRecentRequest,
16546             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
16547         assertTrue(GrouperClientWs.mostRecentRequest,
16548             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
16549         assertTrue(GrouperClientWs.mostRecentRequest,
16550             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
16551         assertTrue(GrouperClientWs.mostRecentRequest,
16552             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
16553         assertTrue(GrouperClientWs.mostRecentRequest,
16554             !GrouperClientWs.mostRecentRequest.contains("params"));
16555         assertTrue(GrouperClientWs.mostRecentRequest,
16556             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
16557         assertTrue(GrouperClientWs.mostRecentRequest,
16558             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
16559         assertTrue(GrouperClientWs.mostRecentRequest,
16560             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
16561         assertTrue(GrouperClientWs.mostRecentRequest,
16562             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
16563         assertTrue(GrouperClientWs.mostRecentRequest,
16564             !GrouperClientWs.mostRecentRequest.contains("roleLookups"));
16565         assertTrue(GrouperClientWs.mostRecentRequest,
16566             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
16567 
16568 
16569         // ######################################################
16570         // Try attributeDefNameUuid
16571 
16572         baos = new ByteArrayOutputStream();
16573         System.setOut(new PrintStream(baos));
16574 
16575         GrouperClient.main(GrouperClientUtils.splitTrim(
16576             "--operation=getPermissionAssignmentsWs --attributeDefNameUuids=" + permissionDefName.getId(),
16577             " "));
16578 
16579 
16580         System.out.flush();
16581         output = new String(baos.toByteArray());
16582 
16583         outputLines = GrouperClientUtils.splitTrim(output, "\n");
16584 
16585         System.setOut(systemOut);
16586 
16587 
16588         assertEquals(1, outputLines.length);
16589         outputLine = outputLines[0];
16590 
16591         matcher = pattern.matcher(outputLines[0]);
16592 
16593         assertTrue(outputLine, matcher.matches());
16594         assertEquals(outputLine, "0", matcher.group(1));
16595         assertEquals(outputLine, "role", matcher.group(2));
16596         assertEquals(outputLine, "aStem:role", matcher.group(3));
16597         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
16598         assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
16599         assertEquals(outputLine, "action", matcher.group(6));
16600         assertEquals(outputLine, "T", matcher.group(7));
16601         assertEquals(outputLine, "T", matcher.group(8));
16602 
16603         assertTrue(GrouperClientWs.mostRecentRequest,
16604             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
16605         assertTrue(GrouperClientWs.mostRecentRequest,
16606             !GrouperClientWs.mostRecentRequest.contains("actions"));
16607         assertTrue(GrouperClientWs.mostRecentRequest,
16608             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
16609         assertTrue(GrouperClientWs.mostRecentRequest,
16610             !GrouperClientWs.mostRecentRequest.contains("enabled"));
16611         assertTrue(GrouperClientWs.mostRecentRequest,
16612             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
16613         assertTrue(GrouperClientWs.mostRecentRequest,
16614             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
16615         assertTrue(GrouperClientWs.mostRecentRequest,
16616             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
16617         assertTrue(GrouperClientWs.mostRecentRequest,
16618             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
16619         assertTrue(GrouperClientWs.mostRecentRequest,
16620             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
16621         assertTrue(GrouperClientWs.mostRecentRequest,
16622             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
16623         assertTrue(GrouperClientWs.mostRecentRequest,
16624             !GrouperClientWs.mostRecentRequest.contains("params"));
16625         assertTrue(GrouperClientWs.mostRecentRequest,
16626             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
16627         assertTrue(GrouperClientWs.mostRecentRequest,
16628             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
16629         assertTrue(GrouperClientWs.mostRecentRequest,
16630             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
16631         assertTrue(GrouperClientWs.mostRecentRequest,
16632             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
16633         assertTrue(GrouperClientWs.mostRecentRequest,
16634             !GrouperClientWs.mostRecentRequest.contains("roleLookups"));
16635         assertTrue(GrouperClientWs.mostRecentRequest,
16636             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
16637 
16638         // ######################################################
16639         // Try attributeDefNameUuid
16640 
16641         baos = new ByteArrayOutputStream();
16642         System.setOut(new PrintStream(baos));
16643 
16644         GrouperClient.main(GrouperClientUtils.splitTrim(
16645             "--operation=getPermissionAssignmentsWs --attributeDefNameIdIndexes=" + permissionDefName.getIdIndex(),
16646             " "));
16647 
16648 
16649         System.out.flush();
16650         output = new String(baos.toByteArray());
16651 
16652         outputLines = GrouperClientUtils.splitTrim(output, "\n");
16653 
16654         System.setOut(systemOut);
16655 
16656 
16657         assertEquals(1, outputLines.length);
16658         outputLine = outputLines[0];
16659 
16660         matcher = pattern.matcher(outputLines[0]);
16661 
16662         assertTrue(outputLine, matcher.matches());
16663         assertEquals(outputLine, "0", matcher.group(1));
16664         assertEquals(outputLine, "role", matcher.group(2));
16665         assertEquals(outputLine, "aStem:role", matcher.group(3));
16666         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
16667         assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
16668         assertEquals(outputLine, "action", matcher.group(6));
16669         assertEquals(outputLine, "T", matcher.group(7));
16670         assertEquals(outputLine, "T", matcher.group(8));
16671 
16672         assertTrue(GrouperClientWs.mostRecentRequest,
16673             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
16674         assertTrue(GrouperClientWs.mostRecentRequest,
16675             !GrouperClientWs.mostRecentRequest.contains("actions"));
16676         assertTrue(GrouperClientWs.mostRecentRequest,
16677             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
16678         assertTrue(GrouperClientWs.mostRecentRequest,
16679             !GrouperClientWs.mostRecentRequest.contains("enabled"));
16680         assertTrue(GrouperClientWs.mostRecentRequest,
16681             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
16682         assertTrue(GrouperClientWs.mostRecentRequest,
16683             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
16684         assertTrue(GrouperClientWs.mostRecentRequest,
16685             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
16686         assertTrue(GrouperClientWs.mostRecentRequest,
16687             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
16688         assertTrue(GrouperClientWs.mostRecentRequest,
16689             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
16690         assertTrue(GrouperClientWs.mostRecentRequest,
16691             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
16692         assertTrue(GrouperClientWs.mostRecentRequest,
16693             !GrouperClientWs.mostRecentRequest.contains("params"));
16694         assertTrue(GrouperClientWs.mostRecentRequest,
16695             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
16696         assertTrue(GrouperClientWs.mostRecentRequest,
16697             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
16698         assertTrue(GrouperClientWs.mostRecentRequest,
16699             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
16700         assertTrue(GrouperClientWs.mostRecentRequest,
16701             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups") && GrouperClientWs.mostRecentRequest.contains("<idIndex>"));
16702         assertTrue(GrouperClientWs.mostRecentRequest,
16703             !GrouperClientWs.mostRecentRequest.contains("roleLookups"));
16704         assertTrue(GrouperClientWs.mostRecentRequest,
16705             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
16706 
16707 
16708         // ######################################################
16709         // Try roleName
16710 
16711         baos = new ByteArrayOutputStream();
16712         System.setOut(new PrintStream(baos));
16713 
16714         GrouperClient.main(GrouperClientUtils.splitTrim(
16715             "--operation=getPermissionAssignmentsWs --roleNames=" + role.getName(),
16716             " "));
16717 
16718 
16719         System.out.flush();
16720         output = new String(baos.toByteArray());
16721 
16722         outputLines = GrouperClientUtils.splitTrim(output, "\n");
16723 
16724         System.setOut(systemOut);
16725 
16726 
16727         assertEquals(1, outputLines.length);
16728         outputLine = outputLines[0];
16729 
16730         matcher = pattern.matcher(outputLines[0]);
16731 
16732         assertTrue(outputLine, matcher.matches());
16733         assertEquals(outputLine, "0", matcher.group(1));
16734         assertEquals(outputLine, "role", matcher.group(2));
16735         assertEquals(outputLine, "aStem:role", matcher.group(3));
16736         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
16737         assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
16738         assertEquals(outputLine, "action", matcher.group(6));
16739         assertEquals(outputLine, "T", matcher.group(7));
16740         assertEquals(outputLine, "T", matcher.group(8));
16741 
16742         assertTrue(GrouperClientWs.mostRecentRequest,
16743             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
16744         assertTrue(GrouperClientWs.mostRecentRequest,
16745             !GrouperClientWs.mostRecentRequest.contains("actions"));
16746         assertTrue(GrouperClientWs.mostRecentRequest,
16747             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
16748         assertTrue(GrouperClientWs.mostRecentRequest,
16749             !GrouperClientWs.mostRecentRequest.contains("enabled"));
16750         assertTrue(GrouperClientWs.mostRecentRequest,
16751             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
16752         assertTrue(GrouperClientWs.mostRecentRequest,
16753             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
16754         assertTrue(GrouperClientWs.mostRecentRequest,
16755             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
16756         assertTrue(GrouperClientWs.mostRecentRequest,
16757             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
16758         assertTrue(GrouperClientWs.mostRecentRequest,
16759             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
16760         assertTrue(GrouperClientWs.mostRecentRequest,
16761             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
16762         assertTrue(GrouperClientWs.mostRecentRequest,
16763             !GrouperClientWs.mostRecentRequest.contains("params"));
16764         assertTrue(GrouperClientWs.mostRecentRequest,
16765             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
16766         assertTrue(GrouperClientWs.mostRecentRequest,
16767             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
16768         assertTrue(GrouperClientWs.mostRecentRequest,
16769             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
16770         assertTrue(GrouperClientWs.mostRecentRequest,
16771             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
16772         assertTrue(GrouperClientWs.mostRecentRequest,
16773             GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
16774         assertTrue(GrouperClientWs.mostRecentRequest,
16775             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
16776 
16777 
16778         // ######################################################
16779         // Try roleUuid
16780 
16781         baos = new ByteArrayOutputStream();
16782         System.setOut(new PrintStream(baos));
16783 
16784         GrouperClient.main(GrouperClientUtils.splitTrim(
16785             "--operation=getPermissionAssignmentsWs --roleUuids=" + role.getId(),
16786             " "));
16787 
16788 
16789         System.out.flush();
16790         output = new String(baos.toByteArray());
16791 
16792         outputLines = GrouperClientUtils.splitTrim(output, "\n");
16793 
16794         System.setOut(systemOut);
16795 
16796 
16797         assertEquals(1, outputLines.length);
16798         outputLine = outputLines[0];
16799 
16800         matcher = pattern.matcher(outputLines[0]);
16801 
16802         assertTrue(outputLine, matcher.matches());
16803         assertEquals(outputLine, "0", matcher.group(1));
16804         assertEquals(outputLine, "role", matcher.group(2));
16805         assertEquals(outputLine, "aStem:role", matcher.group(3));
16806         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
16807         assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
16808         assertEquals(outputLine, "action", matcher.group(6));
16809         assertEquals(outputLine, "T", matcher.group(7));
16810         assertEquals(outputLine, "T", matcher.group(8));
16811 
16812         assertTrue(GrouperClientWs.mostRecentRequest,
16813             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
16814         assertTrue(GrouperClientWs.mostRecentRequest,
16815             !GrouperClientWs.mostRecentRequest.contains("actions"));
16816         assertTrue(GrouperClientWs.mostRecentRequest,
16817             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
16818         assertTrue(GrouperClientWs.mostRecentRequest,
16819             !GrouperClientWs.mostRecentRequest.contains("enabled"));
16820         assertTrue(GrouperClientWs.mostRecentRequest,
16821             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
16822         assertTrue(GrouperClientWs.mostRecentRequest,
16823             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
16824         assertTrue(GrouperClientWs.mostRecentRequest,
16825             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
16826         assertTrue(GrouperClientWs.mostRecentRequest,
16827             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
16828         assertTrue(GrouperClientWs.mostRecentRequest,
16829             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
16830         assertTrue(GrouperClientWs.mostRecentRequest,
16831             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
16832         assertTrue(GrouperClientWs.mostRecentRequest,
16833             !GrouperClientWs.mostRecentRequest.contains("params"));
16834         assertTrue(GrouperClientWs.mostRecentRequest,
16835             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
16836         assertTrue(GrouperClientWs.mostRecentRequest,
16837             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
16838         assertTrue(GrouperClientWs.mostRecentRequest,
16839             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
16840         assertTrue(GrouperClientWs.mostRecentRequest,
16841             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
16842         assertTrue(GrouperClientWs.mostRecentRequest,
16843             GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
16844         assertTrue(GrouperClientWs.mostRecentRequest,
16845             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
16846 
16847 
16848 
16849         // ######################################################
16850         // Try roleIdIndex
16851 
16852         baos = new ByteArrayOutputStream();
16853         System.setOut(new PrintStream(baos));
16854 
16855         GrouperClient.main(GrouperClientUtils.splitTrim(
16856             "--operation=getPermissionAssignmentsWs --roleIdIndexes=" + role.getIdIndex(),
16857             " "));
16858 
16859 
16860         System.out.flush();
16861         output = new String(baos.toByteArray());
16862 
16863         outputLines = GrouperClientUtils.splitTrim(output, "\n");
16864 
16865         System.setOut(systemOut);
16866 
16867 
16868         assertEquals(1, outputLines.length);
16869         outputLine = outputLines[0];
16870 
16871         matcher = pattern.matcher(outputLines[0]);
16872 
16873         assertTrue(outputLine, matcher.matches());
16874         assertEquals(outputLine, "0", matcher.group(1));
16875         assertEquals(outputLine, "role", matcher.group(2));
16876         assertEquals(outputLine, "aStem:role", matcher.group(3));
16877         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
16878         assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
16879         assertEquals(outputLine, "action", matcher.group(6));
16880         assertEquals(outputLine, "T", matcher.group(7));
16881         assertEquals(outputLine, "T", matcher.group(8));
16882 
16883         assertTrue(GrouperClientWs.mostRecentRequest,
16884             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
16885         assertTrue(GrouperClientWs.mostRecentRequest,
16886             !GrouperClientWs.mostRecentRequest.contains("actions"));
16887         assertTrue(GrouperClientWs.mostRecentRequest,
16888             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
16889         assertTrue(GrouperClientWs.mostRecentRequest,
16890             !GrouperClientWs.mostRecentRequest.contains("enabled"));
16891         assertTrue(GrouperClientWs.mostRecentRequest,
16892             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
16893         assertTrue(GrouperClientWs.mostRecentRequest,
16894             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
16895         assertTrue(GrouperClientWs.mostRecentRequest,
16896             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
16897         assertTrue(GrouperClientWs.mostRecentRequest,
16898             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
16899         assertTrue(GrouperClientWs.mostRecentRequest,
16900             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
16901         assertTrue(GrouperClientWs.mostRecentRequest,
16902             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
16903         assertTrue(GrouperClientWs.mostRecentRequest,
16904             !GrouperClientWs.mostRecentRequest.contains("params"));
16905         assertTrue(GrouperClientWs.mostRecentRequest,
16906             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
16907         assertTrue(GrouperClientWs.mostRecentRequest,
16908             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
16909         assertTrue(GrouperClientWs.mostRecentRequest,
16910             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
16911         assertTrue(GrouperClientWs.mostRecentRequest,
16912             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
16913         assertTrue(GrouperClientWs.mostRecentRequest,
16914             GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<idIndex>"));
16915         assertTrue(GrouperClientWs.mostRecentRequest,
16916             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
16917 
16918         // ######################################################
16919         // Try roleName and enabled
16920 
16921         baos = new ByteArrayOutputStream();
16922         System.setOut(new PrintStream(baos));
16923 
16924         GrouperClient.main(GrouperClientUtils.splitTrim(
16925             "--operation=getPermissionAssignmentsWs --roleNames=" + role.getName() + " --enabled=F",
16926             " "));
16927 
16928         System.out.flush();
16929         output = new String(baos.toByteArray());
16930 
16931         System.setOut(systemOut);
16932 
16933         outputLines = GrouperClientUtils.splitTrim(output, "\n");
16934 
16935         assertTrue(outputLines == null || outputLines.length == 0 || StringUtils.isBlank(outputLines[0]));
16936 
16937 
16938         assertTrue(GrouperClientWs.mostRecentRequest,
16939             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
16940         assertTrue(GrouperClientWs.mostRecentRequest,
16941             !GrouperClientWs.mostRecentRequest.contains("actions"));
16942         assertTrue(GrouperClientWs.mostRecentRequest,
16943             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
16944         assertTrue(GrouperClientWs.mostRecentRequest,
16945             GrouperClientWs.mostRecentRequest.contains("enabled"));
16946         assertTrue(GrouperClientWs.mostRecentRequest,
16947             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
16948         assertTrue(GrouperClientWs.mostRecentRequest,
16949             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
16950         assertTrue(GrouperClientWs.mostRecentRequest,
16951             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
16952         assertTrue(GrouperClientWs.mostRecentRequest,
16953             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
16954         assertTrue(GrouperClientWs.mostRecentRequest,
16955             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
16956         assertTrue(GrouperClientWs.mostRecentRequest,
16957             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
16958         assertTrue(GrouperClientWs.mostRecentRequest,
16959             !GrouperClientWs.mostRecentRequest.contains("params"));
16960         assertTrue(GrouperClientWs.mostRecentRequest,
16961             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
16962         assertTrue(GrouperClientWs.mostRecentRequest,
16963             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
16964         assertTrue(GrouperClientWs.mostRecentRequest,
16965             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
16966         assertTrue(GrouperClientWs.mostRecentRequest,
16967             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
16968         assertTrue(GrouperClientWs.mostRecentRequest,
16969             GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
16970         assertTrue(GrouperClientWs.mostRecentRequest,
16971             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
16972 
16973         // ######################################################
16974         // Try roleName and actions
16975 
16976         baos = new ByteArrayOutputStream();
16977         System.setOut(new PrintStream(baos));
16978 
16979         GrouperClient.main(GrouperClientUtils.splitTrim(
16980             "--operation=getPermissionAssignmentsWs --roleNames=" + role.getName() + " --actions=a",
16981             " "));
16982 
16983         System.out.flush();
16984         output = new String(baos.toByteArray());
16985 
16986         System.setOut(systemOut);
16987 
16988         outputLines = GrouperClientUtils.splitTrim(output, "\n");
16989 
16990         assertTrue(outputLines == null || outputLines.length == 0 || StringUtils.isBlank(outputLines[0]));
16991 
16992 
16993         assertTrue(GrouperClientWs.mostRecentRequest,
16994             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
16995         assertTrue(GrouperClientWs.mostRecentRequest,
16996             GrouperClientWs.mostRecentRequest.contains("actions"));
16997         assertTrue(GrouperClientWs.mostRecentRequest,
16998             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
16999         assertTrue(GrouperClientWs.mostRecentRequest,
17000             !GrouperClientWs.mostRecentRequest.contains("enabled"));
17001         assertTrue(GrouperClientWs.mostRecentRequest,
17002             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
17003         assertTrue(GrouperClientWs.mostRecentRequest,
17004             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
17005         assertTrue(GrouperClientWs.mostRecentRequest,
17006             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
17007         assertTrue(GrouperClientWs.mostRecentRequest,
17008             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
17009         assertTrue(GrouperClientWs.mostRecentRequest,
17010             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
17011         assertTrue(GrouperClientWs.mostRecentRequest,
17012             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
17013         assertTrue(GrouperClientWs.mostRecentRequest,
17014             !GrouperClientWs.mostRecentRequest.contains("params"));
17015         assertTrue(GrouperClientWs.mostRecentRequest,
17016             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
17017         assertTrue(GrouperClientWs.mostRecentRequest,
17018             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
17019         assertTrue(GrouperClientWs.mostRecentRequest,
17020             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
17021         assertTrue(GrouperClientWs.mostRecentRequest,
17022             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
17023         assertTrue(GrouperClientWs.mostRecentRequest,
17024             GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
17025         assertTrue(GrouperClientWs.mostRecentRequest,
17026             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
17027 
17028         // ######################################################
17029         // Try roleName and includeAttributeAssignments
17030 
17031         baos = new ByteArrayOutputStream();
17032         System.setOut(new PrintStream(baos));
17033 
17034         GrouperClient.main(GrouperClientUtils.splitTrim(
17035             "--operation=getPermissionAssignmentsWs --roleNames=" + role.getName() + " --includeAttributeAssignments=T",
17036             " "));
17037 
17038         System.out.flush();
17039         output = new String(baos.toByteArray());
17040 
17041         outputLines = GrouperClientUtils.splitTrim(output, "\n");
17042 
17043         System.setOut(systemOut);
17044 
17045 
17046         assertEquals(1, outputLines.length);
17047         outputLine = outputLines[0];
17048 
17049         matcher = pattern.matcher(outputLines[0]);
17050 
17051         assertTrue(outputLine, matcher.matches());
17052         assertEquals(outputLine, "0", matcher.group(1));
17053         assertEquals(outputLine, "role", matcher.group(2));
17054         assertEquals(outputLine, "aStem:role", matcher.group(3));
17055         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
17056         assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
17057         assertEquals(outputLine, "action", matcher.group(6));
17058         assertEquals(outputLine, "T", matcher.group(7));
17059         assertEquals(outputLine, "T", matcher.group(8));
17060 
17061 
17062         assertTrue(GrouperClientWs.mostRecentRequest,
17063             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
17064         assertTrue(GrouperClientWs.mostRecentRequest,
17065             !GrouperClientWs.mostRecentRequest.contains("actions"));
17066         assertTrue(GrouperClientWs.mostRecentRequest,
17067             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
17068         assertTrue(GrouperClientWs.mostRecentRequest,
17069             !GrouperClientWs.mostRecentRequest.contains("enabled"));
17070         assertTrue(GrouperClientWs.mostRecentRequest,
17071             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
17072         assertTrue(GrouperClientWs.mostRecentRequest,
17073             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
17074         assertTrue(GrouperClientWs.mostRecentRequest,
17075             GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
17076         assertTrue(GrouperClientWs.mostRecentResponse,
17077             GrouperClientWs.mostRecentResponse.contains("</WsAttributeAssign>"));
17078         assertTrue(GrouperClientWs.mostRecentRequest,
17079             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
17080         assertTrue(GrouperClientWs.mostRecentRequest,
17081             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
17082         assertTrue(GrouperClientWs.mostRecentRequest,
17083             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
17084         assertTrue(GrouperClientWs.mostRecentRequest,
17085             !GrouperClientWs.mostRecentRequest.contains("params"));
17086         assertTrue(GrouperClientWs.mostRecentRequest,
17087             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
17088         assertTrue(GrouperClientWs.mostRecentRequest,
17089             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
17090         assertTrue(GrouperClientWs.mostRecentRequest,
17091             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
17092         assertTrue(GrouperClientWs.mostRecentRequest,
17093             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
17094         assertTrue(GrouperClientWs.mostRecentRequest,
17095             GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
17096         assertTrue(GrouperClientWs.mostRecentRequest,
17097             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
17098 
17099         // ######################################################
17100         // Try roleName and includeAttributeAssignments and includeAssignmentsOnAssignments
17101 
17102         baos = new ByteArrayOutputStream();
17103         System.setOut(new PrintStream(baos));
17104 
17105         GrouperClient.main(GrouperClientUtils.splitTrim(
17106             "--operation=getPermissionAssignmentsWs --roleNames=" + role.getName() + " --includeAttributeAssignments=T --includeAssignmentsOnAssignments=T",
17107             " "));
17108 
17109         System.out.flush();
17110         output = new String(baos.toByteArray());
17111 
17112         outputLines = GrouperClientUtils.splitTrim(output, "\n");
17113 
17114         System.setOut(systemOut);
17115 
17116 
17117         assertEquals(1, outputLines.length);
17118         outputLine = outputLines[0];
17119 
17120         matcher = pattern.matcher(outputLines[0]);
17121 
17122         assertTrue(outputLine, matcher.matches());
17123         assertEquals(outputLine, "0", matcher.group(1));
17124         assertEquals(outputLine, "role", matcher.group(2));
17125         assertEquals(outputLine, "aStem:role", matcher.group(3));
17126         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
17127         assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
17128         assertEquals(outputLine, "action", matcher.group(6));
17129         assertEquals(outputLine, "T", matcher.group(7));
17130         assertEquals(outputLine, "T", matcher.group(8));
17131 
17132 
17133         assertTrue(GrouperClientWs.mostRecentRequest,
17134             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
17135         assertTrue(GrouperClientWs.mostRecentRequest,
17136             !GrouperClientWs.mostRecentRequest.contains("actions"));
17137         assertTrue(GrouperClientWs.mostRecentRequest,
17138             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
17139         assertTrue(GrouperClientWs.mostRecentRequest,
17140             !GrouperClientWs.mostRecentRequest.contains("enabled"));
17141         assertTrue(GrouperClientWs.mostRecentRequest,
17142             GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
17143         assertTrue(GrouperClientWs.mostRecentRequest,
17144             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
17145         assertTrue(GrouperClientWs.mostRecentRequest,
17146             GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
17147         assertTrue(GrouperClientWs.mostRecentResponse,
17148             GrouperClientWs.mostRecentResponse.contains("</WsAttributeAssign>"));
17149         assertTrue(GrouperClientWs.mostRecentRequest,
17150             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
17151         assertTrue(GrouperClientWs.mostRecentRequest,
17152             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
17153         assertTrue(GrouperClientWs.mostRecentRequest,
17154             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
17155         assertTrue(GrouperClientWs.mostRecentRequest,
17156             !GrouperClientWs.mostRecentRequest.contains("params"));
17157         assertTrue(GrouperClientWs.mostRecentRequest,
17158             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
17159         assertTrue(GrouperClientWs.mostRecentRequest,
17160             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
17161         assertTrue(GrouperClientWs.mostRecentRequest,
17162             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
17163         assertTrue(GrouperClientWs.mostRecentRequest,
17164             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
17165         assertTrue(GrouperClientWs.mostRecentRequest,
17166             GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
17167         assertTrue(GrouperClientWs.mostRecentRequest,
17168             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
17169         assertTrue(GrouperClientWs.mostRecentResponse,
17170             !GrouperClientWs.mostRecentResponse.contains("<attributeDefNameSetDepth>"));
17171 
17172         // ######################################################
17173         // Try roleName and includePermissionAssignDetail
17174 
17175         baos = new ByteArrayOutputStream();
17176         System.setOut(new PrintStream(baos));
17177 
17178         GrouperClient.main(GrouperClientUtils.splitTrim(
17179             "--operation=getPermissionAssignmentsWs --roleNames=" + role.getName() + " --includePermissionAssignDetail=T",
17180             " "));
17181 
17182         System.out.flush();
17183         output = new String(baos.toByteArray());
17184 
17185         outputLines = GrouperClientUtils.splitTrim(output, "\n");
17186 
17187         System.setOut(systemOut);
17188 
17189 
17190         assertEquals(1, outputLines.length);
17191         outputLine = outputLines[0];
17192 
17193         matcher = pattern.matcher(outputLines[0]);
17194 
17195         assertTrue(outputLine, matcher.matches());
17196         assertEquals(outputLine, "0", matcher.group(1));
17197         assertEquals(outputLine, "role", matcher.group(2));
17198         assertEquals(outputLine, "aStem:role", matcher.group(3));
17199         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
17200         assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
17201         assertEquals(outputLine, "action", matcher.group(6));
17202         assertEquals(outputLine, "T", matcher.group(7));
17203         assertEquals(outputLine, "T", matcher.group(8));
17204 
17205 
17206         assertTrue(GrouperClientWs.mostRecentRequest,
17207             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
17208         assertTrue(GrouperClientWs.mostRecentRequest,
17209             !GrouperClientWs.mostRecentRequest.contains("actions"));
17210         assertTrue(GrouperClientWs.mostRecentRequest,
17211             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
17212         assertTrue(GrouperClientWs.mostRecentRequest,
17213             !GrouperClientWs.mostRecentRequest.contains("enabled"));
17214         assertTrue(GrouperClientWs.mostRecentRequest,
17215             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
17216         assertTrue(GrouperClientWs.mostRecentRequest,
17217             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
17218         assertTrue(GrouperClientWs.mostRecentRequest,
17219             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
17220         assertTrue(GrouperClientWs.mostRecentResponse,
17221             GrouperClientWs.mostRecentResponse.contains("<attributeDefNameSetDepth>"));
17222         assertTrue(GrouperClientWs.mostRecentRequest,
17223             GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
17224         assertTrue(GrouperClientWs.mostRecentRequest,
17225             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
17226         assertTrue(GrouperClientWs.mostRecentRequest,
17227             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
17228         assertTrue(GrouperClientWs.mostRecentRequest,
17229             !GrouperClientWs.mostRecentRequest.contains("params"));
17230         assertTrue(GrouperClientWs.mostRecentRequest,
17231             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
17232         assertTrue(GrouperClientWs.mostRecentRequest,
17233             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
17234         assertTrue(GrouperClientWs.mostRecentRequest,
17235             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
17236         assertTrue(GrouperClientWs.mostRecentRequest,
17237             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
17238         assertTrue(GrouperClientWs.mostRecentRequest,
17239             GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
17240         assertTrue(GrouperClientWs.mostRecentRequest,
17241             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
17242         assertTrue(GrouperClientWs.mostRecentResponse,
17243             !GrouperClientWs.mostRecentResponse.contains("<WsAttributeDefName>"));
17244 
17245         // ######################################################
17246         // Try roleName and includeAttributeDefNames
17247 
17248         baos = new ByteArrayOutputStream();
17249         System.setOut(new PrintStream(baos));
17250 
17251         GrouperClient.main(GrouperClientUtils.splitTrim(
17252             "--operation=getPermissionAssignmentsWs --roleNames=" + role.getName() + " --includeAttributeDefNames=T",
17253             " "));
17254 
17255         System.out.flush();
17256         output = new String(baos.toByteArray());
17257 
17258         outputLines = GrouperClientUtils.splitTrim(output, "\n");
17259 
17260         System.setOut(systemOut);
17261 
17262 
17263         assertEquals(1, outputLines.length);
17264         outputLine = outputLines[0];
17265 
17266         matcher = pattern.matcher(outputLines[0]);
17267 
17268         assertTrue(outputLine, matcher.matches());
17269         assertEquals(outputLine, "0", matcher.group(1));
17270         assertEquals(outputLine, "role", matcher.group(2));
17271         assertEquals(outputLine, "aStem:role", matcher.group(3));
17272         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
17273         assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
17274         assertEquals(outputLine, "action", matcher.group(6));
17275         assertEquals(outputLine, "T", matcher.group(7));
17276         assertEquals(outputLine, "T", matcher.group(8));
17277 
17278 
17279         assertTrue(GrouperClientWs.mostRecentRequest,
17280             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
17281         assertTrue(GrouperClientWs.mostRecentRequest,
17282             !GrouperClientWs.mostRecentRequest.contains("actions"));
17283         assertTrue(GrouperClientWs.mostRecentRequest,
17284             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
17285         assertTrue(GrouperClientWs.mostRecentRequest,
17286             !GrouperClientWs.mostRecentRequest.contains("enabled"));
17287         assertTrue(GrouperClientWs.mostRecentRequest,
17288             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
17289         assertTrue(GrouperClientWs.mostRecentRequest,
17290             GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
17291         assertTrue(GrouperClientWs.mostRecentRequest,
17292             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
17293         assertTrue(GrouperClientWs.mostRecentResponse,
17294             GrouperClientWs.mostRecentResponse.contains("<WsAttributeDefName>"));
17295         assertTrue(GrouperClientWs.mostRecentRequest,
17296             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
17297         assertTrue(GrouperClientWs.mostRecentRequest,
17298             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
17299         assertTrue(GrouperClientWs.mostRecentRequest,
17300             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
17301         assertTrue(GrouperClientWs.mostRecentRequest,
17302             !GrouperClientWs.mostRecentRequest.contains("params"));
17303         assertTrue(GrouperClientWs.mostRecentRequest,
17304             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
17305         assertTrue(GrouperClientWs.mostRecentRequest,
17306             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
17307         assertTrue(GrouperClientWs.mostRecentRequest,
17308             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
17309         assertTrue(GrouperClientWs.mostRecentRequest,
17310             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
17311         assertTrue(GrouperClientWs.mostRecentRequest,
17312             GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
17313         assertTrue(GrouperClientWs.mostRecentRequest,
17314             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
17315 
17316         // ######################################################
17317         // Try roleName and includeGroupDetail
17318 
17319         baos = new ByteArrayOutputStream();
17320         System.setOut(new PrintStream(baos));
17321 
17322         GrouperClient.main(GrouperClientUtils.splitTrim(
17323             "--operation=getPermissionAssignmentsWs --roleNames=" + role.getName() + " --includeGroupDetail=T",
17324             " "));
17325 
17326         System.out.flush();
17327         output = new String(baos.toByteArray());
17328 
17329         outputLines = GrouperClientUtils.splitTrim(output, "\n");
17330 
17331         System.setOut(systemOut);
17332 
17333 
17334         assertEquals(1, outputLines.length);
17335         outputLine = outputLines[0];
17336 
17337         matcher = pattern.matcher(outputLines[0]);
17338 
17339         assertTrue(outputLine, matcher.matches());
17340         assertEquals(outputLine, "0", matcher.group(1));
17341         assertEquals(outputLine, "role", matcher.group(2));
17342         assertEquals(outputLine, "aStem:role", matcher.group(3));
17343         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
17344         assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
17345         assertEquals(outputLine, "action", matcher.group(6));
17346         assertEquals(outputLine, "T", matcher.group(7));
17347         assertEquals(outputLine, "T", matcher.group(8));
17348 
17349 
17350         assertTrue(GrouperClientWs.mostRecentRequest,
17351             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
17352         assertTrue(GrouperClientWs.mostRecentRequest,
17353             !GrouperClientWs.mostRecentRequest.contains("actions"));
17354         assertTrue(GrouperClientWs.mostRecentRequest,
17355             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
17356         assertTrue(GrouperClientWs.mostRecentRequest,
17357             !GrouperClientWs.mostRecentRequest.contains("enabled"));
17358         assertTrue(GrouperClientWs.mostRecentRequest,
17359             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
17360         assertTrue(GrouperClientWs.mostRecentRequest,
17361             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
17362         assertTrue(GrouperClientWs.mostRecentRequest,
17363             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
17364         assertTrue(GrouperClientWs.mostRecentResponse,
17365             GrouperClientWs.mostRecentResponse.contains("<hasComposite>"));
17366         assertTrue(GrouperClientWs.mostRecentRequest,
17367             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
17368         assertTrue(GrouperClientWs.mostRecentRequest,
17369             GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
17370         assertTrue(GrouperClientWs.mostRecentRequest,
17371             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
17372         assertTrue(GrouperClientWs.mostRecentRequest,
17373             !GrouperClientWs.mostRecentRequest.contains("params"));
17374         assertTrue(GrouperClientWs.mostRecentRequest,
17375             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
17376         assertTrue(GrouperClientWs.mostRecentRequest,
17377             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
17378         assertTrue(GrouperClientWs.mostRecentRequest,
17379             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
17380         assertTrue(GrouperClientWs.mostRecentRequest,
17381             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
17382         assertTrue(GrouperClientWs.mostRecentRequest,
17383             GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
17384         assertTrue(GrouperClientWs.mostRecentRequest,
17385             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
17386 
17387         // ######################################################
17388         // Try roleName and includeSubjectDetail
17389 
17390         baos = new ByteArrayOutputStream();
17391         System.setOut(new PrintStream(baos));
17392 
17393         GrouperClient.main(GrouperClientUtils.splitTrim(
17394             "--operation=getPermissionAssignmentsWs --roleNames=" + role.getName() + " --includeSubjectDetail=T",
17395             " "));
17396 
17397         System.out.flush();
17398         output = new String(baos.toByteArray());
17399 
17400         outputLines = GrouperClientUtils.splitTrim(output, "\n");
17401 
17402         System.setOut(systemOut);
17403 
17404 
17405         assertEquals(1, outputLines.length);
17406         outputLine = outputLines[0];
17407 
17408         matcher = pattern.matcher(outputLines[0]);
17409 
17410         assertTrue(outputLine, matcher.matches());
17411         assertEquals(outputLine, "0", matcher.group(1));
17412         assertEquals(outputLine, "role", matcher.group(2));
17413         assertEquals(outputLine, "aStem:role", matcher.group(3));
17414         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
17415         assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
17416         assertEquals(outputLine, "action", matcher.group(6));
17417         assertEquals(outputLine, "T", matcher.group(7));
17418         assertEquals(outputLine, "T", matcher.group(8));
17419 
17420 
17421         assertTrue(GrouperClientWs.mostRecentRequest,
17422             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
17423         assertTrue(GrouperClientWs.mostRecentRequest,
17424             !GrouperClientWs.mostRecentRequest.contains("actions"));
17425         assertTrue(GrouperClientWs.mostRecentRequest,
17426             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
17427         assertTrue(GrouperClientWs.mostRecentRequest,
17428             !GrouperClientWs.mostRecentRequest.contains("enabled"));
17429         assertTrue(GrouperClientWs.mostRecentRequest,
17430             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
17431         assertTrue(GrouperClientWs.mostRecentRequest,
17432             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
17433         assertTrue(GrouperClientWs.mostRecentRequest,
17434             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
17435         assertTrue(GrouperClientWs.mostRecentResponse,
17436             !GrouperClientWs.mostRecentResponse.contains("<hasComposite>"));
17437         assertTrue(GrouperClientWs.mostRecentRequest,
17438             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
17439         assertTrue(GrouperClientWs.mostRecentRequest,
17440             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
17441         assertTrue(GrouperClientWs.mostRecentRequest,
17442             GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
17443         assertTrue(GrouperClientWs.mostRecentRequest,
17444             !GrouperClientWs.mostRecentRequest.contains("params"));
17445         assertTrue(GrouperClientWs.mostRecentRequest,
17446             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
17447         assertTrue(GrouperClientWs.mostRecentRequest,
17448             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
17449         assertTrue(GrouperClientWs.mostRecentRequest,
17450             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
17451         assertTrue(GrouperClientWs.mostRecentRequest,
17452             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
17453         assertTrue(GrouperClientWs.mostRecentRequest,
17454             GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
17455         assertTrue(GrouperClientWs.mostRecentRequest,
17456             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
17457 
17458         // ######################################################
17459         // Try roleName and includeSubjectDetail
17460 
17461         baos = new ByteArrayOutputStream();
17462         System.setOut(new PrintStream(baos));
17463 
17464         GrouperClient.main(GrouperClientUtils.splitTrim(
17465             "--operation=getPermissionAssignmentsWs --roleNames=" + role.getName() + " --subjectAttributeNames=abc",
17466             " "));
17467 
17468         System.out.flush();
17469         output = new String(baos.toByteArray());
17470 
17471         outputLines = GrouperClientUtils.splitTrim(output, "\n");
17472 
17473         System.setOut(systemOut);
17474 
17475 
17476         assertEquals(1, outputLines.length);
17477         outputLine = outputLines[0];
17478 
17479         matcher = pattern.matcher(outputLines[0]);
17480 
17481         assertTrue(outputLine, matcher.matches());
17482         assertEquals(outputLine, "0", matcher.group(1));
17483         assertEquals(outputLine, "role", matcher.group(2));
17484         assertEquals(outputLine, "aStem:role", matcher.group(3));
17485         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
17486         assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
17487         assertEquals(outputLine, "action", matcher.group(6));
17488         assertEquals(outputLine, "T", matcher.group(7));
17489         assertEquals(outputLine, "T", matcher.group(8));
17490 
17491 
17492         assertTrue(GrouperClientWs.mostRecentRequest,
17493             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
17494         assertTrue(GrouperClientWs.mostRecentRequest,
17495             !GrouperClientWs.mostRecentRequest.contains("actions"));
17496         assertTrue(GrouperClientWs.mostRecentRequest,
17497             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
17498         assertTrue(GrouperClientWs.mostRecentRequest,
17499             !GrouperClientWs.mostRecentRequest.contains("enabled"));
17500         assertTrue(GrouperClientWs.mostRecentRequest,
17501             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
17502         assertTrue(GrouperClientWs.mostRecentRequest,
17503             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
17504         assertTrue(GrouperClientWs.mostRecentRequest,
17505             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
17506         assertTrue(GrouperClientWs.mostRecentResponse,
17507             !GrouperClientWs.mostRecentResponse.contains("<hasComposite>"));
17508         assertTrue(GrouperClientWs.mostRecentRequest,
17509             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
17510         assertTrue(GrouperClientWs.mostRecentRequest,
17511             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
17512         assertTrue(GrouperClientWs.mostRecentRequest,
17513             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
17514         assertTrue(GrouperClientWs.mostRecentRequest,
17515             !GrouperClientWs.mostRecentRequest.contains("params"));
17516         assertTrue(GrouperClientWs.mostRecentRequest,
17517             GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames") && GrouperClientWs.mostRecentRequest.contains("abc"));
17518         assertTrue(GrouperClientWs.mostRecentRequest,
17519             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
17520         assertTrue(GrouperClientWs.mostRecentRequest,
17521             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
17522         assertTrue(GrouperClientWs.mostRecentRequest,
17523             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
17524         assertTrue(GrouperClientWs.mostRecentRequest,
17525             GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
17526         assertTrue(GrouperClientWs.mostRecentRequest,
17527             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
17528 
17529         // ######################################################
17530         // Try roleName and params
17531 
17532         baos = new ByteArrayOutputStream();
17533         System.setOut(new PrintStream(baos));
17534 
17535         GrouperClient.main(GrouperClientUtils.splitTrim(
17536             "--operation=getPermissionAssignmentsWs --roleNames=" + role.getName() + " --paramName0=a --paramValue0=b",
17537             " "));
17538 
17539         System.out.flush();
17540         output = new String(baos.toByteArray());
17541 
17542         outputLines = GrouperClientUtils.splitTrim(output, "\n");
17543 
17544         System.setOut(systemOut);
17545 
17546 
17547         assertEquals(1, outputLines.length);
17548         outputLine = outputLines[0];
17549 
17550         matcher = pattern.matcher(outputLines[0]);
17551 
17552         assertTrue(outputLine, matcher.matches());
17553         assertEquals(outputLine, "0", matcher.group(1));
17554         assertEquals(outputLine, "role", matcher.group(2));
17555         assertEquals(outputLine, "aStem:role", matcher.group(3));
17556         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
17557         assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
17558         assertEquals(outputLine, "action", matcher.group(6));
17559         assertEquals(outputLine, "T", matcher.group(7));
17560         assertEquals(outputLine, "T", matcher.group(8));
17561 
17562 
17563         assertTrue(GrouperClientWs.mostRecentRequest,
17564             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
17565         assertTrue(GrouperClientWs.mostRecentRequest,
17566             !GrouperClientWs.mostRecentRequest.contains("actions"));
17567         assertTrue(GrouperClientWs.mostRecentRequest,
17568             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
17569         assertTrue(GrouperClientWs.mostRecentRequest,
17570             !GrouperClientWs.mostRecentRequest.contains("enabled"));
17571         assertTrue(GrouperClientWs.mostRecentRequest,
17572             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
17573         assertTrue(GrouperClientWs.mostRecentRequest,
17574             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
17575         assertTrue(GrouperClientWs.mostRecentRequest,
17576             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
17577         assertTrue(GrouperClientWs.mostRecentResponse,
17578             !GrouperClientWs.mostRecentResponse.contains("<hasComposite>"));
17579         assertTrue(GrouperClientWs.mostRecentRequest,
17580             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
17581         assertTrue(GrouperClientWs.mostRecentRequest,
17582             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
17583         assertTrue(GrouperClientWs.mostRecentRequest,
17584             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
17585         assertTrue(GrouperClientWs.mostRecentRequest,
17586             GrouperClientWs.mostRecentRequest.contains("params"));
17587         assertTrue(GrouperClientWs.mostRecentRequest,
17588             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
17589         assertTrue(GrouperClientWs.mostRecentRequest,
17590             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
17591         assertTrue(GrouperClientWs.mostRecentRequest,
17592             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
17593         assertTrue(GrouperClientWs.mostRecentRequest,
17594             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
17595         assertTrue(GrouperClientWs.mostRecentRequest,
17596             GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
17597         assertTrue(GrouperClientWs.mostRecentRequest,
17598             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
17599 
17600         // ######################################################
17601         // Try roleName and custom template
17602 
17603         baos = new ByteArrayOutputStream();
17604         System.setOut(new PrintStream(baos));
17605 
17606         GrouperClient.main(GrouperClientUtils.splitTrim(
17607             "--operation=getPermissionAssignmentsWs --roleNames=" + role.getName() + " --outputTemplate=${wsPermissionAssign.permissionType}$newline$",
17608             " "));
17609 
17610         System.out.flush();
17611         output = new String(baos.toByteArray());
17612 
17613         outputLines = GrouperClientUtils.splitTrim(output, "\n");
17614 
17615         System.setOut(systemOut);
17616 
17617 
17618         assertEquals(1, outputLines.length);
17619         outputLine = outputLines[0].trim();
17620 
17621         assertEquals(outputLine, "role", outputLine);
17622 
17623 
17624         assertTrue(GrouperClientWs.mostRecentRequest,
17625             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
17626         assertTrue(GrouperClientWs.mostRecentRequest,
17627             !GrouperClientWs.mostRecentRequest.contains("actions"));
17628         assertTrue(GrouperClientWs.mostRecentRequest,
17629             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
17630         assertTrue(GrouperClientWs.mostRecentRequest,
17631             !GrouperClientWs.mostRecentRequest.contains("enabled"));
17632         assertTrue(GrouperClientWs.mostRecentRequest,
17633             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
17634         assertTrue(GrouperClientWs.mostRecentRequest,
17635             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
17636         assertTrue(GrouperClientWs.mostRecentRequest,
17637             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
17638         assertTrue(GrouperClientWs.mostRecentResponse,
17639             !GrouperClientWs.mostRecentResponse.contains("<hasComposite>"));
17640         assertTrue(GrouperClientWs.mostRecentRequest,
17641             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
17642         assertTrue(GrouperClientWs.mostRecentRequest,
17643             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
17644         assertTrue(GrouperClientWs.mostRecentRequest,
17645             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
17646         assertTrue(GrouperClientWs.mostRecentRequest,
17647             !GrouperClientWs.mostRecentRequest.contains("params"));
17648         assertTrue(GrouperClientWs.mostRecentRequest,
17649             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
17650         assertTrue(GrouperClientWs.mostRecentRequest,
17651             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
17652         assertTrue(GrouperClientWs.mostRecentRequest,
17653             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
17654         assertTrue(GrouperClientWs.mostRecentRequest,
17655             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
17656         assertTrue(GrouperClientWs.mostRecentRequest,
17657             GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
17658         assertTrue(GrouperClientWs.mostRecentRequest,
17659             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
17660 
17661         // ######################################################
17662         // Try roleName and act as subject
17663         // Should this be an error or a blank result set????
17664 
17665         baos = new ByteArrayOutputStream();
17666         System.setOut(new PrintStream(baos));
17667 
17668         try {
17669           GrouperClient.main(GrouperClientUtils.splitTrim(
17670               "--operation=getPermissionAssignmentsWs --roleNames=" + role.getName() + " --actAsSubjectId=" + SubjectTestHelper.SUBJ0_ID,
17671               " "));
17672         } catch (Exception e) {
17673           assertTrue(ExceptionUtils.getFullStackTrace(e).contains("GROUP_NOT_FOUND"));
17674         }
17675         System.out.flush();
17676 
17677         System.setOut(systemOut);
17678 
17679 
17680 
17681         // ######################################################
17682         // Try roleName and immediateOnly
17683 
17684         baos = new ByteArrayOutputStream();
17685         System.setOut(new PrintStream(baos));
17686 
17687         GrouperClient.main(GrouperClientUtils.splitTrim(
17688             "--operation=getPermissionAssignmentsWs --roleNames=" + role.getName() + " --immediateOnly=T",
17689             " "));
17690 
17691         System.out.flush();
17692         output = new String(baos.toByteArray());
17693 
17694         outputLines = GrouperClientUtils.splitTrim(output, "\n");
17695 
17696         System.setOut(systemOut);
17697 
17698 
17699         assertEquals(0, GrouperUtil.length(outputLines));
17700 
17701 
17702         assertTrue(GrouperClientWs.mostRecentRequest,
17703             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
17704         assertTrue(GrouperClientWs.mostRecentRequest,
17705             !GrouperClientWs.mostRecentRequest.contains("actions"));
17706         assertTrue(GrouperClientWs.mostRecentRequest,
17707             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
17708         assertTrue(GrouperClientWs.mostRecentRequest,
17709             !GrouperClientWs.mostRecentRequest.contains("enabled"));
17710         assertTrue(GrouperClientWs.mostRecentRequest,
17711             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
17712         assertTrue(GrouperClientWs.mostRecentRequest,
17713             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
17714         assertTrue(GrouperClientWs.mostRecentRequest,
17715             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
17716         assertTrue(GrouperClientWs.mostRecentResponse,
17717             !GrouperClientWs.mostRecentResponse.contains("<hasComposite>"));
17718         assertTrue(GrouperClientWs.mostRecentRequest,
17719             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
17720         assertTrue(GrouperClientWs.mostRecentRequest,
17721             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
17722         assertTrue(GrouperClientWs.mostRecentRequest,
17723             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
17724         assertTrue(GrouperClientWs.mostRecentRequest,
17725             !GrouperClientWs.mostRecentRequest.contains("params"));
17726         assertTrue(GrouperClientWs.mostRecentRequest,
17727             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
17728         assertTrue(GrouperClientWs.mostRecentRequest,
17729             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
17730         assertTrue(GrouperClientWs.mostRecentRequest,
17731             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
17732         assertTrue(GrouperClientWs.mostRecentRequest,
17733             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
17734         assertTrue(GrouperClientWs.mostRecentRequest,
17735             GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
17736         assertTrue(GrouperClientWs.mostRecentRequest,
17737             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
17738         assertTrue(GrouperClientWs.mostRecentRequest,
17739             GrouperClientWs.mostRecentRequest.contains("<immediateOnly>T</immediateOnly>"));
17740 
17741         // ######################################################
17742         // Try roleName and permissionType
17743 
17744         baos = new ByteArrayOutputStream();
17745         System.setOut(new PrintStream(baos));
17746 
17747         GrouperClient.main(GrouperClientUtils.splitTrim(
17748             "--operation=getPermissionAssignmentsWs --roleNames=" + role.getName() + " --permissionType=role_subject",
17749             " "));
17750 
17751         System.out.flush();
17752         output = new String(baos.toByteArray());
17753 
17754         outputLines = GrouperClientUtils.splitTrim(output, "\n");
17755 
17756         System.setOut(systemOut);
17757 
17758 
17759         assertEquals(1, GrouperUtil.length(outputLines));
17760 
17761 
17762         assertTrue(GrouperClientWs.mostRecentRequest,
17763             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
17764         assertTrue(GrouperClientWs.mostRecentRequest,
17765             !GrouperClientWs.mostRecentRequest.contains("actions"));
17766         assertTrue(GrouperClientWs.mostRecentRequest,
17767             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
17768         assertTrue(GrouperClientWs.mostRecentRequest,
17769             !GrouperClientWs.mostRecentRequest.contains("enabled"));
17770         assertTrue(GrouperClientWs.mostRecentRequest,
17771             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
17772         assertTrue(GrouperClientWs.mostRecentRequest,
17773             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
17774         assertTrue(GrouperClientWs.mostRecentRequest,
17775             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
17776         assertTrue(GrouperClientWs.mostRecentResponse,
17777             !GrouperClientWs.mostRecentResponse.contains("<hasComposite>"));
17778         assertTrue(GrouperClientWs.mostRecentRequest,
17779             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
17780         assertTrue(GrouperClientWs.mostRecentRequest,
17781             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
17782         assertTrue(GrouperClientWs.mostRecentRequest,
17783             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
17784         assertTrue(GrouperClientWs.mostRecentRequest,
17785             !GrouperClientWs.mostRecentRequest.contains("params"));
17786         assertTrue(GrouperClientWs.mostRecentRequest,
17787             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
17788         assertTrue(GrouperClientWs.mostRecentRequest,
17789             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
17790         assertTrue(GrouperClientWs.mostRecentRequest,
17791             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
17792         assertTrue(GrouperClientWs.mostRecentRequest,
17793             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
17794         assertTrue(GrouperClientWs.mostRecentRequest,
17795             GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
17796         assertTrue(GrouperClientWs.mostRecentRequest,
17797             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
17798         assertTrue(GrouperClientWs.mostRecentRequest,
17799             !GrouperClientWs.mostRecentRequest.contains("<immediateOnly>T</immediateOnly>"));
17800         assertTrue(GrouperClientWs.mostRecentRequest,
17801             GrouperClientWs.mostRecentRequest.contains("<permissionType>role_subject</permissionType>"));
17802         assertTrue(GrouperClientWs.mostRecentRequest,
17803             !GrouperClientWs.mostRecentRequest.contains("<permissionProcessor>role_subject</permissionProcessor>"));
17804 
17805         // ######################################################
17806         // Try roleName and permissionProcessor
17807 
17808         baos = new ByteArrayOutputStream();
17809         System.setOut(new PrintStream(baos));
17810 
17811         GrouperClient.main(GrouperClientUtils.splitTrim(
17812             "--operation=getPermissionAssignmentsWs --roleNames=" + role.getName() + " --permissionProcessor=FILTER_REDUNDANT_PERMISSIONS",
17813             " "));
17814 
17815         System.out.flush();
17816         output = new String(baos.toByteArray());
17817 
17818         outputLines = GrouperClientUtils.splitTrim(output, "\n");
17819 
17820         System.setOut(systemOut);
17821 
17822 
17823         assertEquals(1, GrouperUtil.length(outputLines));
17824 
17825 
17826         assertTrue(GrouperClientWs.mostRecentRequest,
17827             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
17828         assertTrue(GrouperClientWs.mostRecentRequest,
17829             !GrouperClientWs.mostRecentRequest.contains("actions"));
17830         assertTrue(GrouperClientWs.mostRecentRequest,
17831             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
17832         assertTrue(GrouperClientWs.mostRecentRequest,
17833             !GrouperClientWs.mostRecentRequest.contains("enabled"));
17834         assertTrue(GrouperClientWs.mostRecentRequest,
17835             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
17836         assertTrue(GrouperClientWs.mostRecentRequest,
17837             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
17838         assertTrue(GrouperClientWs.mostRecentRequest,
17839             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
17840         assertTrue(GrouperClientWs.mostRecentResponse,
17841             !GrouperClientWs.mostRecentResponse.contains("<hasComposite>"));
17842         assertTrue(GrouperClientWs.mostRecentRequest,
17843             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
17844         assertTrue(GrouperClientWs.mostRecentRequest,
17845             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
17846         assertTrue(GrouperClientWs.mostRecentRequest,
17847             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
17848         assertTrue(GrouperClientWs.mostRecentRequest,
17849             !GrouperClientWs.mostRecentRequest.contains("params"));
17850         assertTrue(GrouperClientWs.mostRecentRequest,
17851             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
17852         assertTrue(GrouperClientWs.mostRecentRequest,
17853             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
17854         assertTrue(GrouperClientWs.mostRecentRequest,
17855             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
17856         assertTrue(GrouperClientWs.mostRecentRequest,
17857             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
17858         assertTrue(GrouperClientWs.mostRecentRequest,
17859             GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
17860         assertTrue(GrouperClientWs.mostRecentRequest,
17861             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
17862         assertTrue(GrouperClientWs.mostRecentRequest,
17863             !GrouperClientWs.mostRecentRequest.contains("<immediateOnly>T</immediateOnly>"));
17864         assertTrue(GrouperClientWs.mostRecentRequest,
17865             !GrouperClientWs.mostRecentRequest.contains("<permissionType>role_subject</permissionType>"));
17866         assertTrue(GrouperClientWs.mostRecentRequest,
17867             GrouperClientWs.mostRecentRequest.contains("<permissionProcessor>FILTER_REDUNDANT_PERMISSIONS</permissionProcessor>"));
17868 
17869       } finally {
17870         System.setOut(systemOut);
17871       }
17872 
17873     }
17874 
17875     /**
17876      * @throws Exception
17877      */
17878     public void testGetPermissionAssignsPIT() throws Exception {
17879 
17880       GrouperSession grouperSession = GrouperSession.startRootSession();
17881 
17882       Stem aStem = Stem.saveStem(grouperSession, "aStem", null,"aStem", "a stem",  "a stem description", null, false);
17883 
17884       //parent implies child
17885       Role role = aStem.addChildRole("role", "role");
17886       Role role2 = aStem.addChildRole("role2", "role2");
17887 
17888       ((Group)role).addMember(SubjectTestHelper.SUBJ0);
17889       ((Group)role2).addMember(SubjectTestHelper.SUBJ1);
17890 
17891       AttributeDef permissionDef = aStem.addChildAttributeDef("permissionDef", AttributeDefType.perm);
17892       permissionDef.setAssignToEffMembership(true);
17893       permissionDef.setAssignToGroup(true);
17894       permissionDef.store();
17895       AttributeDefName permissionDefName = aStem.addChildAttributeDefName(permissionDef, "permissionDefName", "permissionDefName");
17896       AttributeDefName permissionDefName2 = aStem.addChildAttributeDefName(permissionDef, "permissionDefName2", "permissionDefName2");
17897 
17898       permissionDef.getAttributeDefActionDelegate().addAction("action");
17899       permissionDef.getAttributeDefActionDelegate().addAction("action2");
17900 
17901       Thread.sleep(100);
17902       Timestamp before = new Timestamp(new Date().getTime());
17903       Thread.sleep(100);
17904 
17905       //subject 0 has a "role" permission of permissionDefName with "action" in
17906       //subject 1 has a "role_subject" permission of permissionDefName2 with action2
17907 
17908       AttributeAssignResult result1 = role.getPermissionRoleDelegate().assignRolePermission("action", permissionDefName);
17909       AttributeAssignResult result2 = role2.getPermissionRoleDelegate()
17910         .assignSubjectRolePermission("action2", permissionDefName2, SubjectTestHelper.SUBJ1);
17911       ChangeLogTempToEntity.convertRecords();
17912 
17913       Thread.sleep(100);
17914       Timestamp pointInTime = new Timestamp(new Date().getTime());
17915       Thread.sleep(100);
17916 
17917       // delete the permissions...
17918       result1.getAttributeAssign().delete();
17919       result2.getAttributeAssign().delete();
17920       ChangeLogTempToEntity.convertRecords();
17921 
17922       Thread.sleep(100);
17923       Timestamp after = new Timestamp(new Date().getTime());
17924       Thread.sleep(100);
17925 
17926       PrintStream systemOut = System.out;
17927 
17928       ByteArrayOutputStream baos = new ByteArrayOutputStream();
17929       System.setOut(new PrintStream(baos));
17930 
17931       try {
17932 
17933         ArrayList<String> args = new ArrayList<String>();
17934         args.add("--operation=getPermissionAssignmentsWs");
17935         args.add("--attributeDefNames=aStem:permissionDef");
17936         args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTime));
17937         args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTime));
17938         GrouperClient.main(args.toArray(new String[0]));
17939 
17940         System.out.flush();
17941         String output = new String(baos.toByteArray());
17942 
17943         System.setOut(systemOut);
17944 
17945         String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
17946 
17947         // match: Index: 0: permissionType: role, role: aStem:role, subject: jdbc - test.subject.0, attributeDefNameName: aStem:permissionDefName, action: action, enabled: null
17948         // match: Index: 0: permissionType: role, role: aStem:role, subject: jdbc - test.subject.0, attributeDefNameName: aStem:permissionDefName, action: action, allowedOverall: T, enabled:
17949         // match: ^Index: (\d+)\: permissionType\: (.+), role\: (.+), subject\: (.+), attributeDefNameName\: (.+), action\: (.+), enabled\: null
17950         Pattern pattern = Pattern
17951             .compile("^Index: (\\d+)\\: permissionType\\: (.+), role\\: (.+), subject\\: (.+), attributeDefNameName: (.+), action\\: (.+), allowedOverall\\: (T|F), enabled\\:.*$");
17952 
17953         assertEquals(2, outputLines.length);
17954         String outputLine = outputLines[0];
17955 
17956         Matcher matcher = pattern.matcher(outputLines[0]);
17957 
17958         assertTrue(outputLine, matcher.matches());
17959         assertEquals(outputLine, "0", matcher.group(1));
17960         assertEquals(outputLine, "role", matcher.group(2));
17961         assertEquals(outputLine, "aStem:role", matcher.group(3));
17962         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
17963         assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
17964         assertEquals(outputLine, "action", matcher.group(6));
17965 
17966         outputLine = outputLines[1];
17967 
17968         matcher = pattern.matcher(outputLines[1]);
17969 
17970         assertTrue(outputLine, matcher.matches());
17971         assertEquals(outputLine, "1", matcher.group(1));
17972         assertEquals(outputLine, "role_subject", matcher.group(2));
17973         assertEquals(outputLine, "aStem:role2", matcher.group(3));
17974         assertEquals(outputLine, "jdbc - test.subject.1", matcher.group(4));
17975         assertEquals(outputLine, "aStem:permissionDefName2", matcher.group(5));
17976         assertEquals(outputLine, "action2", matcher.group(6));
17977 
17978         assertTrue(GrouperClientWs.mostRecentRequest,
17979             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
17980         assertTrue(GrouperClientWs.mostRecentRequest,
17981             !GrouperClientWs.mostRecentRequest.contains("actions"));
17982         assertTrue(GrouperClientWs.mostRecentRequest,
17983             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
17984         assertTrue(GrouperClientWs.mostRecentRequest,
17985             !GrouperClientWs.mostRecentRequest.contains("enabled"));
17986         assertTrue(GrouperClientWs.mostRecentRequest,
17987             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
17988         assertTrue(GrouperClientWs.mostRecentRequest,
17989             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
17990         assertTrue(GrouperClientWs.mostRecentRequest,
17991             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
17992         assertTrue(GrouperClientWs.mostRecentRequest,
17993             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
17994         assertTrue(GrouperClientWs.mostRecentRequest,
17995             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
17996         assertTrue(GrouperClientWs.mostRecentRequest,
17997             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
17998         assertTrue(GrouperClientWs.mostRecentRequest,
17999             !GrouperClientWs.mostRecentRequest.contains("params"));
18000         assertTrue(GrouperClientWs.mostRecentRequest,
18001             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
18002         assertTrue(GrouperClientWs.mostRecentRequest,
18003             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
18004         assertTrue(GrouperClientWs.mostRecentRequest,
18005             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
18006         assertTrue(GrouperClientWs.mostRecentRequest,
18007             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
18008         assertTrue(GrouperClientWs.mostRecentRequest,
18009             !GrouperClientWs.mostRecentRequest.contains("roleLookups"));
18010         assertTrue(GrouperClientWs.mostRecentRequest,
18011             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
18012 
18013 
18014 
18015 
18016         // ######################################################
18017         // Try attributeDefId
18018 
18019         baos = new ByteArrayOutputStream();
18020         System.setOut(new PrintStream(baos));
18021 
18022         args = new ArrayList<String>();
18023         args.add("--operation=getPermissionAssignmentsWs");
18024         args.add("--attributeDefUuids=" + permissionDef.getId());
18025         args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTime));
18026         args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTime));
18027         GrouperClient.main(args.toArray(new String[0]));
18028 
18029         System.out.flush();
18030         output = new String(baos.toByteArray());
18031 
18032         outputLines = GrouperClientUtils.splitTrim(output, "\n");
18033 
18034         System.setOut(systemOut);
18035 
18036 
18037         assertEquals(2, outputLines.length);
18038         outputLine = outputLines[0];
18039 
18040         matcher = pattern.matcher(outputLines[0]);
18041 
18042         assertTrue(outputLine, matcher.matches());
18043         assertEquals(outputLine, "0", matcher.group(1));
18044         assertEquals(outputLine, "role", matcher.group(2));
18045         assertEquals(outputLine, "aStem:role", matcher.group(3));
18046         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
18047         assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
18048         assertEquals(outputLine, "action", matcher.group(6));
18049 
18050         outputLine = outputLines[1];
18051 
18052         matcher = pattern.matcher(outputLines[1]);
18053 
18054         assertTrue(outputLine, matcher.matches());
18055         assertEquals(outputLine, "1", matcher.group(1));
18056         assertEquals(outputLine, "role_subject", matcher.group(2));
18057         assertEquals(outputLine, "aStem:role2", matcher.group(3));
18058         assertEquals(outputLine, "jdbc - test.subject.1", matcher.group(4));
18059         assertEquals(outputLine, "aStem:permissionDefName2", matcher.group(5));
18060         assertEquals(outputLine, "action2", matcher.group(6));
18061 
18062         assertTrue(GrouperClientWs.mostRecentRequest,
18063             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
18064         assertTrue(GrouperClientWs.mostRecentRequest,
18065             !GrouperClientWs.mostRecentRequest.contains("actions"));
18066         assertTrue(GrouperClientWs.mostRecentRequest,
18067             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
18068         assertTrue(GrouperClientWs.mostRecentRequest,
18069             !GrouperClientWs.mostRecentRequest.contains("enabled"));
18070         assertTrue(GrouperClientWs.mostRecentRequest,
18071             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
18072         assertTrue(GrouperClientWs.mostRecentRequest,
18073             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
18074         assertTrue(GrouperClientWs.mostRecentRequest,
18075             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
18076         assertTrue(GrouperClientWs.mostRecentRequest,
18077             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
18078         assertTrue(GrouperClientWs.mostRecentRequest,
18079             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
18080         assertTrue(GrouperClientWs.mostRecentRequest,
18081             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
18082         assertTrue(GrouperClientWs.mostRecentRequest,
18083             !GrouperClientWs.mostRecentRequest.contains("params"));
18084         assertTrue(GrouperClientWs.mostRecentRequest,
18085             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
18086         assertTrue(GrouperClientWs.mostRecentRequest,
18087             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
18088         assertTrue(GrouperClientWs.mostRecentRequest,
18089             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
18090         assertTrue(GrouperClientWs.mostRecentRequest,
18091             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
18092         assertTrue(GrouperClientWs.mostRecentRequest,
18093             !GrouperClientWs.mostRecentRequest.contains("roleLookups"));
18094         assertTrue(GrouperClientWs.mostRecentRequest,
18095             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
18096 
18097 
18098 
18099         // ######################################################
18100         // Try attributeDefNameName
18101 
18102         baos = new ByteArrayOutputStream();
18103         System.setOut(new PrintStream(baos));
18104 
18105         args = new ArrayList<String>();
18106         args.add("--operation=getPermissionAssignmentsWs");
18107         args.add("--attributeDefNameNames=" + permissionDefName.getName());
18108         args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTime));
18109         args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTime));
18110         GrouperClient.main(args.toArray(new String[0]));
18111 
18112         System.out.flush();
18113         output = new String(baos.toByteArray());
18114 
18115         outputLines = GrouperClientUtils.splitTrim(output, "\n");
18116 
18117         System.setOut(systemOut);
18118 
18119 
18120         assertEquals(1, outputLines.length);
18121         outputLine = outputLines[0];
18122 
18123         matcher = pattern.matcher(outputLines[0]);
18124 
18125         assertTrue(outputLine, matcher.matches());
18126         assertEquals(outputLine, "0", matcher.group(1));
18127         assertEquals(outputLine, "role", matcher.group(2));
18128         assertEquals(outputLine, "aStem:role", matcher.group(3));
18129         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
18130         assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
18131         assertEquals(outputLine, "action", matcher.group(6));
18132 
18133         assertTrue(GrouperClientWs.mostRecentRequest,
18134             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
18135         assertTrue(GrouperClientWs.mostRecentRequest,
18136             !GrouperClientWs.mostRecentRequest.contains("actions"));
18137         assertTrue(GrouperClientWs.mostRecentRequest,
18138             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
18139         assertTrue(GrouperClientWs.mostRecentRequest,
18140             !GrouperClientWs.mostRecentRequest.contains("enabled"));
18141         assertTrue(GrouperClientWs.mostRecentRequest,
18142             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
18143         assertTrue(GrouperClientWs.mostRecentRequest,
18144             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
18145         assertTrue(GrouperClientWs.mostRecentRequest,
18146             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
18147         assertTrue(GrouperClientWs.mostRecentRequest,
18148             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
18149         assertTrue(GrouperClientWs.mostRecentRequest,
18150             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
18151         assertTrue(GrouperClientWs.mostRecentRequest,
18152             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
18153         assertTrue(GrouperClientWs.mostRecentRequest,
18154             !GrouperClientWs.mostRecentRequest.contains("params"));
18155         assertTrue(GrouperClientWs.mostRecentRequest,
18156             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
18157         assertTrue(GrouperClientWs.mostRecentRequest,
18158             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
18159         assertTrue(GrouperClientWs.mostRecentRequest,
18160             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
18161         assertTrue(GrouperClientWs.mostRecentRequest,
18162             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
18163         assertTrue(GrouperClientWs.mostRecentRequest,
18164             !GrouperClientWs.mostRecentRequest.contains("roleLookups"));
18165         assertTrue(GrouperClientWs.mostRecentRequest,
18166             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
18167 
18168 
18169         // ######################################################
18170         // Try attributeDefNameUuid
18171 
18172         baos = new ByteArrayOutputStream();
18173         System.setOut(new PrintStream(baos));
18174 
18175         args = new ArrayList<String>();
18176         args.add("--operation=getPermissionAssignmentsWs");
18177         args.add("--attributeDefNameUuids=" + permissionDefName.getId());
18178         args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTime));
18179         args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTime));
18180         GrouperClient.main(args.toArray(new String[0]));
18181 
18182         System.out.flush();
18183         output = new String(baos.toByteArray());
18184 
18185         outputLines = GrouperClientUtils.splitTrim(output, "\n");
18186 
18187         System.setOut(systemOut);
18188 
18189 
18190         assertEquals(1, outputLines.length);
18191         outputLine = outputLines[0];
18192 
18193         matcher = pattern.matcher(outputLines[0]);
18194 
18195         assertTrue(outputLine, matcher.matches());
18196         assertEquals(outputLine, "0", matcher.group(1));
18197         assertEquals(outputLine, "role", matcher.group(2));
18198         assertEquals(outputLine, "aStem:role", matcher.group(3));
18199         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
18200         assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
18201         assertEquals(outputLine, "action", matcher.group(6));
18202 
18203         assertTrue(GrouperClientWs.mostRecentRequest,
18204             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
18205         assertTrue(GrouperClientWs.mostRecentRequest,
18206             !GrouperClientWs.mostRecentRequest.contains("actions"));
18207         assertTrue(GrouperClientWs.mostRecentRequest,
18208             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
18209         assertTrue(GrouperClientWs.mostRecentRequest,
18210             !GrouperClientWs.mostRecentRequest.contains("enabled"));
18211         assertTrue(GrouperClientWs.mostRecentRequest,
18212             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
18213         assertTrue(GrouperClientWs.mostRecentRequest,
18214             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
18215         assertTrue(GrouperClientWs.mostRecentRequest,
18216             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
18217         assertTrue(GrouperClientWs.mostRecentRequest,
18218             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
18219         assertTrue(GrouperClientWs.mostRecentRequest,
18220             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
18221         assertTrue(GrouperClientWs.mostRecentRequest,
18222             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
18223         assertTrue(GrouperClientWs.mostRecentRequest,
18224             !GrouperClientWs.mostRecentRequest.contains("params"));
18225         assertTrue(GrouperClientWs.mostRecentRequest,
18226             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
18227         assertTrue(GrouperClientWs.mostRecentRequest,
18228             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
18229         assertTrue(GrouperClientWs.mostRecentRequest,
18230             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
18231         assertTrue(GrouperClientWs.mostRecentRequest,
18232             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
18233         assertTrue(GrouperClientWs.mostRecentRequest,
18234             !GrouperClientWs.mostRecentRequest.contains("roleLookups"));
18235         assertTrue(GrouperClientWs.mostRecentRequest,
18236             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
18237 
18238 
18239         // ######################################################
18240         // Try roleName
18241 
18242         baos = new ByteArrayOutputStream();
18243         System.setOut(new PrintStream(baos));
18244 
18245         args = new ArrayList<String>();
18246         args.add("--operation=getPermissionAssignmentsWs");
18247         args.add("--roleNames=" + role.getName());
18248         args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTime));
18249         args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTime));
18250         GrouperClient.main(args.toArray(new String[0]));
18251 
18252         System.out.flush();
18253         output = new String(baos.toByteArray());
18254 
18255         outputLines = GrouperClientUtils.splitTrim(output, "\n");
18256 
18257         System.setOut(systemOut);
18258 
18259 
18260         assertEquals(1, outputLines.length);
18261         outputLine = outputLines[0];
18262 
18263         matcher = pattern.matcher(outputLines[0]);
18264 
18265         assertTrue(outputLine, matcher.matches());
18266         assertEquals(outputLine, "0", matcher.group(1));
18267         assertEquals(outputLine, "role", matcher.group(2));
18268         assertEquals(outputLine, "aStem:role", matcher.group(3));
18269         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
18270         assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
18271         assertEquals(outputLine, "action", matcher.group(6));
18272 
18273         assertTrue(GrouperClientWs.mostRecentRequest,
18274             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
18275         assertTrue(GrouperClientWs.mostRecentRequest,
18276             !GrouperClientWs.mostRecentRequest.contains("actions"));
18277         assertTrue(GrouperClientWs.mostRecentRequest,
18278             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
18279         assertTrue(GrouperClientWs.mostRecentRequest,
18280             !GrouperClientWs.mostRecentRequest.contains("enabled"));
18281         assertTrue(GrouperClientWs.mostRecentRequest,
18282             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
18283         assertTrue(GrouperClientWs.mostRecentRequest,
18284             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
18285         assertTrue(GrouperClientWs.mostRecentRequest,
18286             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
18287         assertTrue(GrouperClientWs.mostRecentRequest,
18288             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
18289         assertTrue(GrouperClientWs.mostRecentRequest,
18290             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
18291         assertTrue(GrouperClientWs.mostRecentRequest,
18292             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
18293         assertTrue(GrouperClientWs.mostRecentRequest,
18294             !GrouperClientWs.mostRecentRequest.contains("params"));
18295         assertTrue(GrouperClientWs.mostRecentRequest,
18296             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
18297         assertTrue(GrouperClientWs.mostRecentRequest,
18298             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
18299         assertTrue(GrouperClientWs.mostRecentRequest,
18300             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
18301         assertTrue(GrouperClientWs.mostRecentRequest,
18302             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
18303         assertTrue(GrouperClientWs.mostRecentRequest,
18304             GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
18305         assertTrue(GrouperClientWs.mostRecentRequest,
18306             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
18307 
18308 
18309         // ######################################################
18310         // Try roleUuid
18311 
18312         baos = new ByteArrayOutputStream();
18313         System.setOut(new PrintStream(baos));
18314 
18315         args = new ArrayList<String>();
18316         args.add("--operation=getPermissionAssignmentsWs");
18317         args.add("--roleUuids=" + role.getId());
18318         args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTime));
18319         args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTime));
18320         GrouperClient.main(args.toArray(new String[0]));
18321 
18322         System.out.flush();
18323         output = new String(baos.toByteArray());
18324 
18325         outputLines = GrouperClientUtils.splitTrim(output, "\n");
18326 
18327         System.setOut(systemOut);
18328 
18329 
18330         assertEquals(1, outputLines.length);
18331         outputLine = outputLines[0];
18332 
18333         matcher = pattern.matcher(outputLines[0]);
18334 
18335         assertTrue(outputLine, matcher.matches());
18336         assertEquals(outputLine, "0", matcher.group(1));
18337         assertEquals(outputLine, "role", matcher.group(2));
18338         assertEquals(outputLine, "aStem:role", matcher.group(3));
18339         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
18340         assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
18341         assertEquals(outputLine, "action", matcher.group(6));
18342 
18343         assertTrue(GrouperClientWs.mostRecentRequest,
18344             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
18345         assertTrue(GrouperClientWs.mostRecentRequest,
18346             !GrouperClientWs.mostRecentRequest.contains("actions"));
18347         assertTrue(GrouperClientWs.mostRecentRequest,
18348             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
18349         assertTrue(GrouperClientWs.mostRecentRequest,
18350             !GrouperClientWs.mostRecentRequest.contains("enabled"));
18351         assertTrue(GrouperClientWs.mostRecentRequest,
18352             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
18353         assertTrue(GrouperClientWs.mostRecentRequest,
18354             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
18355         assertTrue(GrouperClientWs.mostRecentRequest,
18356             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
18357         assertTrue(GrouperClientWs.mostRecentRequest,
18358             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
18359         assertTrue(GrouperClientWs.mostRecentRequest,
18360             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
18361         assertTrue(GrouperClientWs.mostRecentRequest,
18362             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
18363         assertTrue(GrouperClientWs.mostRecentRequest,
18364             !GrouperClientWs.mostRecentRequest.contains("params"));
18365         assertTrue(GrouperClientWs.mostRecentRequest,
18366             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
18367         assertTrue(GrouperClientWs.mostRecentRequest,
18368             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
18369         assertTrue(GrouperClientWs.mostRecentRequest,
18370             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
18371         assertTrue(GrouperClientWs.mostRecentRequest,
18372             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
18373         assertTrue(GrouperClientWs.mostRecentRequest,
18374             GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
18375         assertTrue(GrouperClientWs.mostRecentRequest,
18376             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
18377 
18378         // ######################################################
18379         // Try roleName and actions
18380 
18381         baos = new ByteArrayOutputStream();
18382         System.setOut(new PrintStream(baos));
18383 
18384         args = new ArrayList<String>();
18385         args.add("--operation=getPermissionAssignmentsWs");
18386         args.add("--roleNames=" + role.getName());
18387         args.add("--actions=a");
18388         args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTime));
18389         args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTime));
18390         GrouperClient.main(args.toArray(new String[0]));
18391 
18392         System.out.flush();
18393         output = new String(baos.toByteArray());
18394 
18395         System.setOut(systemOut);
18396 
18397         outputLines = GrouperClientUtils.splitTrim(output, "\n");
18398 
18399         assertTrue(outputLines == null || outputLines.length == 0 || StringUtils.isBlank(outputLines[0]));
18400 
18401 
18402         assertTrue(GrouperClientWs.mostRecentRequest,
18403             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
18404         assertTrue(GrouperClientWs.mostRecentRequest,
18405             GrouperClientWs.mostRecentRequest.contains("actions"));
18406         assertTrue(GrouperClientWs.mostRecentRequest,
18407             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
18408         assertTrue(GrouperClientWs.mostRecentRequest,
18409             !GrouperClientWs.mostRecentRequest.contains("enabled"));
18410         assertTrue(GrouperClientWs.mostRecentRequest,
18411             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
18412         assertTrue(GrouperClientWs.mostRecentRequest,
18413             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
18414         assertTrue(GrouperClientWs.mostRecentRequest,
18415             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
18416         assertTrue(GrouperClientWs.mostRecentRequest,
18417             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
18418         assertTrue(GrouperClientWs.mostRecentRequest,
18419             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
18420         assertTrue(GrouperClientWs.mostRecentRequest,
18421             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
18422         assertTrue(GrouperClientWs.mostRecentRequest,
18423             !GrouperClientWs.mostRecentRequest.contains("params"));
18424         assertTrue(GrouperClientWs.mostRecentRequest,
18425             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
18426         assertTrue(GrouperClientWs.mostRecentRequest,
18427             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
18428         assertTrue(GrouperClientWs.mostRecentRequest,
18429             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
18430         assertTrue(GrouperClientWs.mostRecentRequest,
18431             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
18432         assertTrue(GrouperClientWs.mostRecentRequest,
18433             GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
18434         assertTrue(GrouperClientWs.mostRecentRequest,
18435             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
18436 
18437         // ######################################################
18438         // Try roleName and includeAttributeAssignments
18439 
18440         baos = new ByteArrayOutputStream();
18441         System.setOut(new PrintStream(baos));
18442 
18443         args = new ArrayList<String>();
18444         args.add("--operation=getPermissionAssignmentsWs");
18445         args.add("--roleNames=" + role.getName());
18446         args.add("--includeAttributeAssignments=T");
18447         args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTime));
18448         args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTime));
18449         GrouperClient.main(args.toArray(new String[0]));
18450 
18451         System.out.flush();
18452         output = new String(baos.toByteArray());
18453 
18454         outputLines = GrouperClientUtils.splitTrim(output, "\n");
18455 
18456         System.setOut(systemOut);
18457 
18458 
18459         assertEquals(1, outputLines.length);
18460         outputLine = outputLines[0];
18461 
18462         matcher = pattern.matcher(outputLines[0]);
18463 
18464         assertTrue(outputLine, matcher.matches());
18465         assertEquals(outputLine, "0", matcher.group(1));
18466         assertEquals(outputLine, "role", matcher.group(2));
18467         assertEquals(outputLine, "aStem:role", matcher.group(3));
18468         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
18469         assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
18470         assertEquals(outputLine, "action", matcher.group(6));
18471 
18472 
18473         assertTrue(GrouperClientWs.mostRecentRequest,
18474             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
18475         assertTrue(GrouperClientWs.mostRecentRequest,
18476             !GrouperClientWs.mostRecentRequest.contains("actions"));
18477         assertTrue(GrouperClientWs.mostRecentRequest,
18478             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
18479         assertTrue(GrouperClientWs.mostRecentRequest,
18480             !GrouperClientWs.mostRecentRequest.contains("enabled"));
18481         assertTrue(GrouperClientWs.mostRecentRequest,
18482             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
18483         assertTrue(GrouperClientWs.mostRecentRequest,
18484             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
18485         assertTrue(GrouperClientWs.mostRecentRequest,
18486             GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
18487         assertTrue(GrouperClientWs.mostRecentResponse,
18488             GrouperClientWs.mostRecentResponse.contains("</WsAttributeAssign>"));
18489         assertTrue(GrouperClientWs.mostRecentRequest,
18490             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
18491         assertTrue(GrouperClientWs.mostRecentRequest,
18492             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
18493         assertTrue(GrouperClientWs.mostRecentRequest,
18494             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
18495         assertTrue(GrouperClientWs.mostRecentRequest,
18496             !GrouperClientWs.mostRecentRequest.contains("params"));
18497         assertTrue(GrouperClientWs.mostRecentRequest,
18498             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
18499         assertTrue(GrouperClientWs.mostRecentRequest,
18500             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
18501         assertTrue(GrouperClientWs.mostRecentRequest,
18502             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
18503         assertTrue(GrouperClientWs.mostRecentRequest,
18504             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
18505         assertTrue(GrouperClientWs.mostRecentRequest,
18506             GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
18507         assertTrue(GrouperClientWs.mostRecentRequest,
18508             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
18509 
18510         // ######################################################
18511         // Try roleName and includeAttributeAssignments and includeAssignmentsOnAssignments
18512 
18513         baos = new ByteArrayOutputStream();
18514         System.setOut(new PrintStream(baos));
18515 
18516         args = new ArrayList<String>();
18517         args.add("--operation=getPermissionAssignmentsWs");
18518         args.add("--roleNames=" + role.getName());
18519         args.add("--includeAttributeAssignments=T");
18520         args.add("--includeAssignmentsOnAssignments=T");
18521         args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTime));
18522         args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTime));
18523         GrouperClient.main(args.toArray(new String[0]));
18524 
18525         System.out.flush();
18526         output = new String(baos.toByteArray());
18527 
18528         outputLines = GrouperClientUtils.splitTrim(output, "\n");
18529 
18530         System.setOut(systemOut);
18531 
18532 
18533         assertEquals(1, outputLines.length);
18534         outputLine = outputLines[0];
18535 
18536         matcher = pattern.matcher(outputLines[0]);
18537 
18538         assertTrue(outputLine, matcher.matches());
18539         assertEquals(outputLine, "0", matcher.group(1));
18540         assertEquals(outputLine, "role", matcher.group(2));
18541         assertEquals(outputLine, "aStem:role", matcher.group(3));
18542         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
18543         assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
18544         assertEquals(outputLine, "action", matcher.group(6));
18545 
18546 
18547         assertTrue(GrouperClientWs.mostRecentRequest,
18548             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
18549         assertTrue(GrouperClientWs.mostRecentRequest,
18550             !GrouperClientWs.mostRecentRequest.contains("actions"));
18551         assertTrue(GrouperClientWs.mostRecentRequest,
18552             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
18553         assertTrue(GrouperClientWs.mostRecentRequest,
18554             !GrouperClientWs.mostRecentRequest.contains("enabled"));
18555         assertTrue(GrouperClientWs.mostRecentRequest,
18556             GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
18557         assertTrue(GrouperClientWs.mostRecentRequest,
18558             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
18559         assertTrue(GrouperClientWs.mostRecentRequest,
18560             GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
18561         assertTrue(GrouperClientWs.mostRecentResponse,
18562             GrouperClientWs.mostRecentResponse.contains("</WsAttributeAssign>"));
18563         assertTrue(GrouperClientWs.mostRecentRequest,
18564             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
18565         assertTrue(GrouperClientWs.mostRecentRequest,
18566             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
18567         assertTrue(GrouperClientWs.mostRecentRequest,
18568             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
18569         assertTrue(GrouperClientWs.mostRecentRequest,
18570             !GrouperClientWs.mostRecentRequest.contains("params"));
18571         assertTrue(GrouperClientWs.mostRecentRequest,
18572             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
18573         assertTrue(GrouperClientWs.mostRecentRequest,
18574             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
18575         assertTrue(GrouperClientWs.mostRecentRequest,
18576             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
18577         assertTrue(GrouperClientWs.mostRecentRequest,
18578             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
18579         assertTrue(GrouperClientWs.mostRecentRequest,
18580             GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
18581         assertTrue(GrouperClientWs.mostRecentRequest,
18582             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
18583         assertTrue(GrouperClientWs.mostRecentResponse,
18584             !GrouperClientWs.mostRecentResponse.contains("<attributeDefNameSetDepth>"));
18585 
18586         // ######################################################
18587         // Try roleName and includePermissionAssignDetail
18588 
18589         baos = new ByteArrayOutputStream();
18590         System.setOut(new PrintStream(baos));
18591 
18592         args = new ArrayList<String>();
18593         args.add("--operation=getPermissionAssignmentsWs");
18594         args.add("--roleNames=" + role.getName());
18595         args.add("--includePermissionAssignDetail=T");
18596         args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTime));
18597         args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTime));
18598         GrouperClient.main(args.toArray(new String[0]));
18599 
18600         System.out.flush();
18601         output = new String(baos.toByteArray());
18602 
18603         outputLines = GrouperClientUtils.splitTrim(output, "\n");
18604 
18605         System.setOut(systemOut);
18606 
18607 
18608         assertEquals(1, outputLines.length);
18609         outputLine = outputLines[0];
18610 
18611         matcher = pattern.matcher(outputLines[0]);
18612 
18613         assertTrue(outputLine, matcher.matches());
18614         assertEquals(outputLine, "0", matcher.group(1));
18615         assertEquals(outputLine, "role", matcher.group(2));
18616         assertEquals(outputLine, "aStem:role", matcher.group(3));
18617         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
18618         assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
18619         assertEquals(outputLine, "action", matcher.group(6));
18620 
18621 
18622         assertTrue(GrouperClientWs.mostRecentRequest,
18623             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
18624         assertTrue(GrouperClientWs.mostRecentRequest,
18625             !GrouperClientWs.mostRecentRequest.contains("actions"));
18626         assertTrue(GrouperClientWs.mostRecentRequest,
18627             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
18628         assertTrue(GrouperClientWs.mostRecentRequest,
18629             !GrouperClientWs.mostRecentRequest.contains("enabled"));
18630         assertTrue(GrouperClientWs.mostRecentRequest,
18631             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
18632         assertTrue(GrouperClientWs.mostRecentRequest,
18633             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
18634         assertTrue(GrouperClientWs.mostRecentRequest,
18635             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
18636         assertTrue(GrouperClientWs.mostRecentResponse,
18637             GrouperClientWs.mostRecentResponse.contains("<attributeDefNameSetDepth>"));
18638         assertTrue(GrouperClientWs.mostRecentRequest,
18639             GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
18640         assertTrue(GrouperClientWs.mostRecentRequest,
18641             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
18642         assertTrue(GrouperClientWs.mostRecentRequest,
18643             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
18644         assertTrue(GrouperClientWs.mostRecentRequest,
18645             !GrouperClientWs.mostRecentRequest.contains("params"));
18646         assertTrue(GrouperClientWs.mostRecentRequest,
18647             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
18648         assertTrue(GrouperClientWs.mostRecentRequest,
18649             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
18650         assertTrue(GrouperClientWs.mostRecentRequest,
18651             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
18652         assertTrue(GrouperClientWs.mostRecentRequest,
18653             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
18654         assertTrue(GrouperClientWs.mostRecentRequest,
18655             GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
18656         assertTrue(GrouperClientWs.mostRecentRequest,
18657             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
18658         assertTrue(GrouperClientWs.mostRecentResponse,
18659             !GrouperClientWs.mostRecentResponse.contains("<WsAttributeDefName>"));
18660 
18661         // ######################################################
18662         // Try roleName and includeAttributeDefNames
18663 
18664         baos = new ByteArrayOutputStream();
18665         System.setOut(new PrintStream(baos));
18666 
18667         args = new ArrayList<String>();
18668         args.add("--operation=getPermissionAssignmentsWs");
18669         args.add("--roleNames=" + role.getName());
18670         args.add("--includeAttributeDefNames=T");
18671         args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTime));
18672         args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTime));
18673         GrouperClient.main(args.toArray(new String[0]));
18674 
18675         System.out.flush();
18676         output = new String(baos.toByteArray());
18677 
18678         outputLines = GrouperClientUtils.splitTrim(output, "\n");
18679 
18680         System.setOut(systemOut);
18681 
18682 
18683         assertEquals(1, outputLines.length);
18684         outputLine = outputLines[0];
18685 
18686         matcher = pattern.matcher(outputLines[0]);
18687 
18688         assertTrue(outputLine, matcher.matches());
18689         assertEquals(outputLine, "0", matcher.group(1));
18690         assertEquals(outputLine, "role", matcher.group(2));
18691         assertEquals(outputLine, "aStem:role", matcher.group(3));
18692         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
18693         assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
18694         assertEquals(outputLine, "action", matcher.group(6));
18695 
18696 
18697         assertTrue(GrouperClientWs.mostRecentRequest,
18698             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
18699         assertTrue(GrouperClientWs.mostRecentRequest,
18700             !GrouperClientWs.mostRecentRequest.contains("actions"));
18701         assertTrue(GrouperClientWs.mostRecentRequest,
18702             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
18703         assertTrue(GrouperClientWs.mostRecentRequest,
18704             !GrouperClientWs.mostRecentRequest.contains("enabled"));
18705         assertTrue(GrouperClientWs.mostRecentRequest,
18706             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
18707         assertTrue(GrouperClientWs.mostRecentRequest,
18708             GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
18709         assertTrue(GrouperClientWs.mostRecentRequest,
18710             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
18711         assertTrue(GrouperClientWs.mostRecentResponse,
18712             GrouperClientWs.mostRecentResponse.contains("<WsAttributeDefName>"));
18713         assertTrue(GrouperClientWs.mostRecentRequest,
18714             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
18715         assertTrue(GrouperClientWs.mostRecentRequest,
18716             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
18717         assertTrue(GrouperClientWs.mostRecentRequest,
18718             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
18719         assertTrue(GrouperClientWs.mostRecentRequest,
18720             !GrouperClientWs.mostRecentRequest.contains("params"));
18721         assertTrue(GrouperClientWs.mostRecentRequest,
18722             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
18723         assertTrue(GrouperClientWs.mostRecentRequest,
18724             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
18725         assertTrue(GrouperClientWs.mostRecentRequest,
18726             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
18727         assertTrue(GrouperClientWs.mostRecentRequest,
18728             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
18729         assertTrue(GrouperClientWs.mostRecentRequest,
18730             GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
18731         assertTrue(GrouperClientWs.mostRecentRequest,
18732             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
18733 
18734         // ######################################################
18735         // Try roleName and includeSubjectDetail
18736 
18737         baos = new ByteArrayOutputStream();
18738         System.setOut(new PrintStream(baos));
18739 
18740         args = new ArrayList<String>();
18741         args.add("--operation=getPermissionAssignmentsWs");
18742         args.add("--roleNames=" + role.getName());
18743         args.add("--includeSubjectDetail=T");
18744         args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTime));
18745         args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTime));
18746         GrouperClient.main(args.toArray(new String[0]));
18747 
18748         System.out.flush();
18749         output = new String(baos.toByteArray());
18750 
18751         outputLines = GrouperClientUtils.splitTrim(output, "\n");
18752 
18753         System.setOut(systemOut);
18754 
18755 
18756         assertEquals(1, outputLines.length);
18757         outputLine = outputLines[0];
18758 
18759         matcher = pattern.matcher(outputLines[0]);
18760 
18761         assertTrue(outputLine, matcher.matches());
18762         assertEquals(outputLine, "0", matcher.group(1));
18763         assertEquals(outputLine, "role", matcher.group(2));
18764         assertEquals(outputLine, "aStem:role", matcher.group(3));
18765         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
18766         assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
18767         assertEquals(outputLine, "action", matcher.group(6));
18768 
18769 
18770         assertTrue(GrouperClientWs.mostRecentRequest,
18771             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
18772         assertTrue(GrouperClientWs.mostRecentRequest,
18773             !GrouperClientWs.mostRecentRequest.contains("actions"));
18774         assertTrue(GrouperClientWs.mostRecentRequest,
18775             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
18776         assertTrue(GrouperClientWs.mostRecentRequest,
18777             !GrouperClientWs.mostRecentRequest.contains("enabled"));
18778         assertTrue(GrouperClientWs.mostRecentRequest,
18779             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
18780         assertTrue(GrouperClientWs.mostRecentRequest,
18781             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
18782         assertTrue(GrouperClientWs.mostRecentRequest,
18783             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
18784         assertTrue(GrouperClientWs.mostRecentResponse,
18785             !GrouperClientWs.mostRecentResponse.contains("<hasComposite>"));
18786         assertTrue(GrouperClientWs.mostRecentRequest,
18787             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
18788         assertTrue(GrouperClientWs.mostRecentRequest,
18789             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
18790         assertTrue(GrouperClientWs.mostRecentRequest,
18791             GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
18792         assertTrue(GrouperClientWs.mostRecentRequest,
18793             !GrouperClientWs.mostRecentRequest.contains("params"));
18794         assertTrue(GrouperClientWs.mostRecentRequest,
18795             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
18796         assertTrue(GrouperClientWs.mostRecentRequest,
18797             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
18798         assertTrue(GrouperClientWs.mostRecentRequest,
18799             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
18800         assertTrue(GrouperClientWs.mostRecentRequest,
18801             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
18802         assertTrue(GrouperClientWs.mostRecentRequest,
18803             GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
18804         assertTrue(GrouperClientWs.mostRecentRequest,
18805             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
18806 
18807         // ######################################################
18808         // Try roleName and subjectAttributeNames
18809 
18810         baos = new ByteArrayOutputStream();
18811         System.setOut(new PrintStream(baos));
18812 
18813         args = new ArrayList<String>();
18814         args.add("--operation=getPermissionAssignmentsWs");
18815         args.add("--roleNames=" + role.getName());
18816         args.add("--subjectAttributeNames=abc");
18817         args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTime));
18818         args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTime));
18819         GrouperClient.main(args.toArray(new String[0]));
18820 
18821         System.out.flush();
18822         output = new String(baos.toByteArray());
18823 
18824         outputLines = GrouperClientUtils.splitTrim(output, "\n");
18825 
18826         System.setOut(systemOut);
18827 
18828 
18829         assertEquals(1, outputLines.length);
18830         outputLine = outputLines[0];
18831 
18832         matcher = pattern.matcher(outputLines[0]);
18833 
18834         assertTrue(outputLine, matcher.matches());
18835         assertEquals(outputLine, "0", matcher.group(1));
18836         assertEquals(outputLine, "role", matcher.group(2));
18837         assertEquals(outputLine, "aStem:role", matcher.group(3));
18838         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
18839         assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
18840         assertEquals(outputLine, "action", matcher.group(6));
18841 
18842 
18843         assertTrue(GrouperClientWs.mostRecentRequest,
18844             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
18845         assertTrue(GrouperClientWs.mostRecentRequest,
18846             !GrouperClientWs.mostRecentRequest.contains("actions"));
18847         assertTrue(GrouperClientWs.mostRecentRequest,
18848             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
18849         assertTrue(GrouperClientWs.mostRecentRequest,
18850             !GrouperClientWs.mostRecentRequest.contains("enabled"));
18851         assertTrue(GrouperClientWs.mostRecentRequest,
18852             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
18853         assertTrue(GrouperClientWs.mostRecentRequest,
18854             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
18855         assertTrue(GrouperClientWs.mostRecentRequest,
18856             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
18857         assertTrue(GrouperClientWs.mostRecentResponse,
18858             !GrouperClientWs.mostRecentResponse.contains("<hasComposite>"));
18859         assertTrue(GrouperClientWs.mostRecentRequest,
18860             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
18861         assertTrue(GrouperClientWs.mostRecentRequest,
18862             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
18863         assertTrue(GrouperClientWs.mostRecentRequest,
18864             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
18865         assertTrue(GrouperClientWs.mostRecentRequest,
18866             !GrouperClientWs.mostRecentRequest.contains("params"));
18867         assertTrue(GrouperClientWs.mostRecentRequest,
18868             GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames") && GrouperClientWs.mostRecentRequest.contains("abc"));
18869         assertTrue(GrouperClientWs.mostRecentRequest,
18870             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
18871         assertTrue(GrouperClientWs.mostRecentRequest,
18872             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
18873         assertTrue(GrouperClientWs.mostRecentRequest,
18874             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
18875         assertTrue(GrouperClientWs.mostRecentRequest,
18876             GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
18877         assertTrue(GrouperClientWs.mostRecentRequest,
18878             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
18879 
18880         // ######################################################
18881         // Try roleName and params
18882 
18883         baos = new ByteArrayOutputStream();
18884         System.setOut(new PrintStream(baos));
18885 
18886         args = new ArrayList<String>();
18887         args.add("--operation=getPermissionAssignmentsWs");
18888         args.add("--roleNames=" + role.getName());
18889         args.add("--paramName0=a");
18890         args.add("--paramValue0=b");
18891         args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTime));
18892         args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTime));
18893         GrouperClient.main(args.toArray(new String[0]));
18894 
18895         System.out.flush();
18896         output = new String(baos.toByteArray());
18897 
18898         outputLines = GrouperClientUtils.splitTrim(output, "\n");
18899 
18900         System.setOut(systemOut);
18901 
18902 
18903         assertEquals(1, outputLines.length);
18904         outputLine = outputLines[0];
18905 
18906         matcher = pattern.matcher(outputLines[0]);
18907 
18908         assertTrue(outputLine, matcher.matches());
18909         assertEquals(outputLine, "0", matcher.group(1));
18910         assertEquals(outputLine, "role", matcher.group(2));
18911         assertEquals(outputLine, "aStem:role", matcher.group(3));
18912         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
18913         assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
18914         assertEquals(outputLine, "action", matcher.group(6));
18915 
18916 
18917         assertTrue(GrouperClientWs.mostRecentRequest,
18918             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
18919         assertTrue(GrouperClientWs.mostRecentRequest,
18920             !GrouperClientWs.mostRecentRequest.contains("actions"));
18921         assertTrue(GrouperClientWs.mostRecentRequest,
18922             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
18923         assertTrue(GrouperClientWs.mostRecentRequest,
18924             !GrouperClientWs.mostRecentRequest.contains("enabled"));
18925         assertTrue(GrouperClientWs.mostRecentRequest,
18926             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
18927         assertTrue(GrouperClientWs.mostRecentRequest,
18928             !GrouperClientWs.mostRecentRequest.contains("includeAttributeDefNames"));
18929         assertTrue(GrouperClientWs.mostRecentRequest,
18930             !GrouperClientWs.mostRecentRequest.contains("includeAttributeAssignments"));
18931         assertTrue(GrouperClientWs.mostRecentResponse,
18932             !GrouperClientWs.mostRecentResponse.contains("<hasComposite>"));
18933         assertTrue(GrouperClientWs.mostRecentRequest,
18934             !GrouperClientWs.mostRecentRequest.contains("includePermissionAssignDetail"));
18935         assertTrue(GrouperClientWs.mostRecentRequest,
18936             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
18937         assertTrue(GrouperClientWs.mostRecentRequest,
18938             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
18939         assertTrue(GrouperClientWs.mostRecentRequest,
18940             GrouperClientWs.mostRecentRequest.contains("params"));
18941         assertTrue(GrouperClientWs.mostRecentRequest,
18942             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
18943         assertTrue(GrouperClientWs.mostRecentRequest,
18944             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
18945         assertTrue(GrouperClientWs.mostRecentRequest,
18946             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
18947         assertTrue(GrouperClientWs.mostRecentRequest,
18948             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
18949         assertTrue(GrouperClientWs.mostRecentRequest,
18950             GrouperClientWs.mostRecentRequest.contains("roleLookups") && GrouperClientWs.mostRecentRequest.contains("<groupName>"));
18951         assertTrue(GrouperClientWs.mostRecentRequest,
18952             !GrouperClientWs.mostRecentRequest.contains("wsSubjectLookups"));
18953 
18954         // ######################################################
18955         // Try roleName and actAsSubjectId
18956 
18957         baos = new ByteArrayOutputStream();
18958         System.setOut(new PrintStream(baos));
18959 
18960         args = new ArrayList<String>();
18961         args.add("--operation=getPermissionAssignmentsWs");
18962         args.add("--roleNames=" + role.getName());
18963         args.add("--actAsSubjectId=" + SubjectTestHelper.SUBJ0_ID);
18964         args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(pointInTime));
18965         args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(pointInTime));
18966 
18967         try {
18968           GrouperClient.main(args.toArray(new String[0]));
18969         } catch (Exception e) {
18970           assertTrue(ExceptionUtils.getFullStackTrace(e).contains("GROUP_NOT_FOUND"));
18971         }
18972         System.out.flush();
18973 
18974         System.setOut(systemOut);
18975 
18976 
18977 
18978         // ######################################################
18979         // Try roleName and pointInTimeFrom only
18980 
18981         baos = new ByteArrayOutputStream();
18982         System.setOut(new PrintStream(baos));
18983 
18984         args = new ArrayList<String>();
18985         args.add("--operation=getPermissionAssignmentsWs");
18986         args.add("--roleNames=" + role.getName());
18987         args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(after));
18988         GrouperClient.main(args.toArray(new String[0]));
18989 
18990         System.out.flush();
18991         output = new String(baos.toByteArray());
18992 
18993         System.setOut(systemOut);
18994 
18995         outputLines = GrouperClientUtils.splitTrim(output, "\n");
18996 
18997         assertTrue(outputLines == null || outputLines.length == 0 || StringUtils.isBlank(outputLines[0]));
18998 
18999         // ######################################################
19000         // Try roleName and pointInTimeFrom only
19001 
19002         baos = new ByteArrayOutputStream();
19003         System.setOut(new PrintStream(baos));
19004 
19005         args = new ArrayList<String>();
19006         args.add("--operation=getPermissionAssignmentsWs");
19007         args.add("--roleNames=" + role.getName());
19008         args.add("--pointInTimeFrom=" + GrouperClientUtils.timestampToString(before));
19009         GrouperClient.main(args.toArray(new String[0]));
19010 
19011         System.out.flush();
19012         output = new String(baos.toByteArray());
19013 
19014         System.setOut(systemOut);
19015 
19016         outputLines = GrouperClientUtils.splitTrim(output, "\n");
19017 
19018         assertEquals(1, outputLines.length);
19019         outputLine = outputLines[0];
19020 
19021         matcher = pattern.matcher(outputLines[0]);
19022 
19023         assertTrue(outputLine, matcher.matches());
19024         assertEquals(outputLine, "0", matcher.group(1));
19025         assertEquals(outputLine, "role", matcher.group(2));
19026         assertEquals(outputLine, "aStem:role", matcher.group(3));
19027         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
19028         assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
19029         assertEquals(outputLine, "action", matcher.group(6));
19030 
19031 
19032         // ######################################################
19033         // Try roleName and pointInTimeTo only
19034 
19035         baos = new ByteArrayOutputStream();
19036         System.setOut(new PrintStream(baos));
19037 
19038         args = new ArrayList<String>();
19039         args.add("--operation=getPermissionAssignmentsWs");
19040         args.add("--roleNames=" + role.getName());
19041         args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(before));
19042         GrouperClient.main(args.toArray(new String[0]));
19043 
19044         System.out.flush();
19045         output = new String(baos.toByteArray());
19046 
19047         System.setOut(systemOut);
19048 
19049         outputLines = GrouperClientUtils.splitTrim(output, "\n");
19050 
19051         assertTrue(outputLines == null || outputLines.length == 0 || StringUtils.isBlank(outputLines[0]));
19052 
19053         // ######################################################
19054         // Try roleName and pointInTimeTo only
19055 
19056         baos = new ByteArrayOutputStream();
19057         System.setOut(new PrintStream(baos));
19058 
19059         args = new ArrayList<String>();
19060         args.add("--operation=getPermissionAssignmentsWs");
19061         args.add("--roleNames=" + role.getName());
19062         args.add("--pointInTimeTo=" + GrouperClientUtils.timestampToString(after));
19063         GrouperClient.main(args.toArray(new String[0]));
19064 
19065         System.out.flush();
19066         output = new String(baos.toByteArray());
19067 
19068         System.setOut(systemOut);
19069 
19070         outputLines = GrouperClientUtils.splitTrim(output, "\n");
19071 
19072         assertEquals(1, outputLines.length);
19073         outputLine = outputLines[0];
19074 
19075         matcher = pattern.matcher(outputLines[0]);
19076 
19077         assertTrue(outputLine, matcher.matches());
19078         assertEquals(outputLine, "0", matcher.group(1));
19079         assertEquals(outputLine, "role", matcher.group(2));
19080         assertEquals(outputLine, "aStem:role", matcher.group(3));
19081         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(4));
19082         assertEquals(outputLine, "aStem:permissionDefName", matcher.group(5));
19083         assertEquals(outputLine, "action", matcher.group(6));
19084 
19085 
19086       } finally {
19087         System.setOut(systemOut);
19088       }
19089 
19090     }
19091 
19092   /**
19093    * @throws Exception
19094    */
19095   public void testAssignPermissions() throws Exception {
19096 
19097     AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb(
19098         AttributeDefType.perm, "test", "testAttributeAssignDefName");
19099 
19100     final AttributeDef attributeDef = attributeDefName.getAttributeDef();
19101 
19102     attributeDef.setAssignToEffMembership(true);
19103     attributeDef.setAssignToGroup(true);
19104     attributeDef.store();
19105 
19106     Group group = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
19107       .assignGroupNameToEdit("test:groupTestAttrAssign").assignName("test:groupTestAttrAssign").assignCreateParentStemsIfNotExist(true)
19108       .assignDescription("description").assignTypeOfGroup(TypeOfGroup.role).save();
19109 
19110     //test subject 0 can view and read
19111     group.grantPriv(SubjectTestHelper.SUBJ0, AccessPrivilege.VIEW);
19112     attributeDef.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ0, AttributeDefPrivilege.ATTR_READ, false);
19113 
19114     AttributeAssign attributeAssign = null;
19115     //    AttributeAssignResult attributeAssignResult = group.getAttributeDelegate().assignAttribute(attributeDefName);
19116     //     = attributeAssignResult.getAttributeAssign();
19117 
19118     PrintStream systemOut = System.out;
19119 
19120     ByteArrayOutputStream baos = new ByteArrayOutputStream();
19121     System.setOut(new PrintStream(baos));
19122 
19123     try {
19124 
19125       GrouperClient.main(GrouperClientUtils.splitTrim(
19126           "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=assign_permission " +
19127           "--permissionDefNameNames=test:testAttributeAssignDefName --roleNames=test:groupTestAttrAssign",
19128           " "));
19129 
19130       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
19131 
19132       System.out.flush();
19133       String output = new String(baos.toByteArray());
19134 
19135       System.setOut(systemOut);
19136 
19137       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
19138 
19139       // match: Index: 0: attributeAssignType: group, owner: test:groupTestAttrAssign, attributeDefNameNameName test:testAttributeAssignDefName, action: assign, values: 15,5,5, enable: T, id: a9c83eeb78c04ae5befcea36272d318c, changed: true, valuesChanged: false
19140       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F), changed\: (T|F), valuesChanged\: (T|F)$
19141       Pattern pattern = Pattern
19142           .compile("^Index\\: (\\d+)\\: permissionType\\: (.+), owner\\: (.+), permissionDefNameName\\: (.+), action\\: (.+), disallowed\\: (.+), enabled\\: (T|F), attributeAssignId\\: (.+), changed\\: (T|F), deleted\\: (T|F)$");
19143       String outputLine = outputLines[0];
19144 
19145       Matcher matcher = pattern.matcher(outputLines[0]);
19146 
19147       assertTrue(outputLine, matcher.matches());
19148       assertEquals(outputLine, "0", matcher.group(1));
19149       assertEquals(outputLine, "role", matcher.group(2));
19150       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
19151       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
19152       assertEquals(outputLine, "assign", matcher.group(5));
19153 
19154       assertEquals(outputLine, "F", matcher.group(6));
19155       assertEquals(outputLine, "T", matcher.group(7));
19156       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
19157       assertEquals(outputLine, "T", matcher.group(9));
19158 
19159 
19160       assertTrue(GrouperClientWs.mostRecentRequest,
19161           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
19162       assertTrue(GrouperClientWs.mostRecentRequest,
19163           !GrouperClientWs.mostRecentRequest.contains("actions"));
19164       assertTrue(GrouperClientWs.mostRecentRequest,
19165           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
19166       assertTrue(GrouperClientWs.mostRecentRequest,
19167           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
19168       assertTrue(GrouperClientWs.mostRecentRequest,
19169           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
19170       assertTrue(GrouperClientWs.mostRecentRequest,
19171           GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
19172       assertTrue(GrouperClientWs.mostRecentRequest,
19173           GrouperClientWs.mostRecentRequest.contains("permissionType"));
19174       assertTrue(GrouperClientWs.mostRecentRequest,
19175           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
19176       assertTrue(GrouperClientWs.mostRecentRequest,
19177           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
19178       assertTrue(GrouperClientWs.mostRecentRequest,
19179           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
19180       assertTrue(GrouperClientWs.mostRecentRequest,
19181           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
19182       assertTrue(GrouperClientWs.mostRecentRequest,
19183           !GrouperClientWs.mostRecentRequest.contains("params"));
19184       assertTrue(GrouperClientWs.mostRecentRequest,
19185           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
19186       assertTrue(GrouperClientWs.mostRecentRequest,
19187           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
19188       assertTrue(GrouperClientWs.mostRecentRequest,
19189           GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
19190           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
19191       assertTrue(GrouperClientWs.mostRecentRequest,
19192           GrouperClientWs.mostRecentRequest.contains("roleLookups")
19193           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
19194       assertTrue(GrouperClientWs.mostRecentRequest,
19195           !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
19196       assertTrue(GrouperClientWs.mostRecentResponse,
19197           GrouperClientWs.mostRecentResponse.contains("disallowed"));
19198 
19199       // ######################################################
19200       // Try permissionId
19201 
19202       baos = new ByteArrayOutputStream();
19203       System.setOut(new PrintStream(baos));
19204 
19205       GrouperClient.main(GrouperClientUtils.splitTrim(
19206           "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=assign_permission " +
19207           "--permissionDefNameUuids=" + attributeDefName.getId() +  " --roleNames=test:groupTestAttrAssign",
19208           " "));
19209 
19210       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
19211 
19212       System.out.flush();
19213       output = new String(baos.toByteArray());
19214 
19215       System.setOut(systemOut);
19216 
19217       outputLines = GrouperClientUtils.splitTrim(output, "\n");
19218 
19219       outputLine = outputLines[0];
19220 
19221       matcher = pattern.matcher(outputLines[0]);
19222 
19223       assertTrue(outputLine, matcher.matches());
19224       assertEquals(outputLine, "0", matcher.group(1));
19225       assertEquals(outputLine, "role", matcher.group(2));
19226       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
19227       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
19228       assertEquals(outputLine, "assign", matcher.group(5));
19229 
19230       assertEquals(outputLine, "F", matcher.group(6));
19231       assertEquals(outputLine, "T", matcher.group(7));
19232       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
19233       assertEquals(outputLine, "F", matcher.group(9));
19234 
19235 
19236       assertTrue(GrouperClientWs.mostRecentRequest,
19237           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
19238       assertTrue(GrouperClientWs.mostRecentRequest,
19239           !GrouperClientWs.mostRecentRequest.contains("actions"));
19240       assertTrue(GrouperClientWs.mostRecentRequest,
19241           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
19242       assertTrue(GrouperClientWs.mostRecentRequest,
19243           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
19244       assertTrue(GrouperClientWs.mostRecentRequest,
19245           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
19246       assertTrue(GrouperClientWs.mostRecentRequest,
19247           GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
19248       assertTrue(GrouperClientWs.mostRecentRequest,
19249           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
19250       assertTrue(GrouperClientWs.mostRecentRequest,
19251           GrouperClientWs.mostRecentRequest.contains("permissionType"));
19252       assertTrue(GrouperClientWs.mostRecentRequest,
19253           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
19254       assertTrue(GrouperClientWs.mostRecentRequest,
19255           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
19256       assertTrue(GrouperClientWs.mostRecentRequest,
19257           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
19258       assertTrue(GrouperClientWs.mostRecentRequest,
19259           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
19260       assertTrue(GrouperClientWs.mostRecentRequest,
19261           !GrouperClientWs.mostRecentRequest.contains("params"));
19262       assertTrue(GrouperClientWs.mostRecentRequest,
19263           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
19264       assertTrue(GrouperClientWs.mostRecentRequest,
19265           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
19266       assertTrue(GrouperClientWs.mostRecentRequest,
19267           GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
19268           && GrouperClientWs.mostRecentRequest.contains(attributeDefName.getId()));
19269       assertTrue(GrouperClientWs.mostRecentRequest,
19270           GrouperClientWs.mostRecentRequest.contains("roleLookups")
19271           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
19272       assertTrue(GrouperClientWs.mostRecentRequest,
19273           !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
19274 
19275 
19276       // ######################################################
19277       // Try permissionIdIOndex
19278 
19279       baos = new ByteArrayOutputStream();
19280       System.setOut(new PrintStream(baos));
19281 
19282       GrouperClient.main(GrouperClientUtils.splitTrim(
19283           "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=assign_permission " +
19284           "--permissionDefNameIdIndexes=" + attributeDefName.getIdIndex() +  " --roleNames=test:groupTestAttrAssign",
19285           " "));
19286 
19287       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
19288 
19289       System.out.flush();
19290       output = new String(baos.toByteArray());
19291 
19292       System.setOut(systemOut);
19293 
19294       outputLines = GrouperClientUtils.splitTrim(output, "\n");
19295 
19296       outputLine = outputLines[0];
19297 
19298       matcher = pattern.matcher(outputLines[0]);
19299 
19300       assertTrue(outputLine, matcher.matches());
19301       assertEquals(outputLine, "0", matcher.group(1));
19302       assertEquals(outputLine, "role", matcher.group(2));
19303       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
19304       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
19305       assertEquals(outputLine, "assign", matcher.group(5));
19306 
19307       assertEquals(outputLine, "F", matcher.group(6));
19308       assertEquals(outputLine, "T", matcher.group(7));
19309       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
19310       assertEquals(outputLine, "F", matcher.group(9));
19311 
19312 
19313       assertTrue(GrouperClientWs.mostRecentRequest,
19314           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
19315       assertTrue(GrouperClientWs.mostRecentRequest,
19316           !GrouperClientWs.mostRecentRequest.contains("actions"));
19317       assertTrue(GrouperClientWs.mostRecentRequest,
19318           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
19319       assertTrue(GrouperClientWs.mostRecentRequest,
19320           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
19321       assertTrue(GrouperClientWs.mostRecentRequest,
19322           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
19323       assertTrue(GrouperClientWs.mostRecentRequest,
19324           GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
19325       assertTrue(GrouperClientWs.mostRecentRequest,
19326           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
19327       assertTrue(GrouperClientWs.mostRecentRequest,
19328           GrouperClientWs.mostRecentRequest.contains("permissionType"));
19329       assertTrue(GrouperClientWs.mostRecentRequest,
19330           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
19331       assertTrue(GrouperClientWs.mostRecentRequest,
19332           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
19333       assertTrue(GrouperClientWs.mostRecentRequest,
19334           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
19335       assertTrue(GrouperClientWs.mostRecentRequest,
19336           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
19337       assertTrue(GrouperClientWs.mostRecentRequest,
19338           !GrouperClientWs.mostRecentRequest.contains("params"));
19339       assertTrue(GrouperClientWs.mostRecentRequest,
19340           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
19341       assertTrue(GrouperClientWs.mostRecentRequest,
19342           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
19343       assertTrue(GrouperClientWs.mostRecentRequest,
19344           GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
19345           && GrouperClientWs.mostRecentRequest.contains(attributeDefName.getIdIndex().toString()));
19346       assertTrue(GrouperClientWs.mostRecentRequest,
19347           GrouperClientWs.mostRecentRequest.contains("roleLookups")
19348           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
19349       assertTrue(GrouperClientWs.mostRecentRequest,
19350           !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
19351 
19352       // ######################################################
19353       // Try ownerGroupUuid
19354 
19355       baos = new ByteArrayOutputStream();
19356       System.setOut(new PrintStream(baos));
19357 
19358       GrouperClient.main(GrouperClientUtils.splitTrim(
19359           "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=assign_permission " +
19360           "--permissionDefNameNames=test:testAttributeAssignDefName --roleUuids=" + group.getUuid(),
19361           " "));
19362 
19363       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
19364 
19365       System.out.flush();
19366       output = new String(baos.toByteArray());
19367 
19368       System.setOut(systemOut);
19369 
19370       outputLines = GrouperClientUtils.splitTrim(output, "\n");
19371 
19372       outputLine = outputLines[0];
19373 
19374       matcher = pattern.matcher(outputLines[0]);
19375 
19376       assertTrue(outputLine, matcher.matches());
19377       assertEquals(outputLine, "0", matcher.group(1));
19378       assertEquals(outputLine, "role", matcher.group(2));
19379       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
19380       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
19381       assertEquals(outputLine, "assign", matcher.group(5));
19382 
19383       assertEquals(outputLine, "F", matcher.group(6));
19384       assertEquals(outputLine, "T", matcher.group(7));
19385       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
19386       assertEquals(outputLine, "F", matcher.group(9));
19387 
19388 
19389       assertTrue(GrouperClientWs.mostRecentRequest,
19390           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
19391       assertTrue(GrouperClientWs.mostRecentRequest,
19392           !GrouperClientWs.mostRecentRequest.contains("actions"));
19393       assertTrue(GrouperClientWs.mostRecentRequest,
19394           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
19395       assertTrue(GrouperClientWs.mostRecentRequest,
19396           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
19397       assertTrue(GrouperClientWs.mostRecentRequest,
19398           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
19399       assertTrue(GrouperClientWs.mostRecentRequest,
19400           GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
19401       assertTrue(GrouperClientWs.mostRecentRequest,
19402           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
19403       assertTrue(GrouperClientWs.mostRecentRequest,
19404           GrouperClientWs.mostRecentRequest.contains("permissionType"));
19405       assertTrue(GrouperClientWs.mostRecentRequest,
19406           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
19407       assertTrue(GrouperClientWs.mostRecentRequest,
19408           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
19409       assertTrue(GrouperClientWs.mostRecentRequest,
19410           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
19411       assertTrue(GrouperClientWs.mostRecentRequest,
19412           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
19413       assertTrue(GrouperClientWs.mostRecentRequest,
19414           !GrouperClientWs.mostRecentRequest.contains("params"));
19415       assertTrue(GrouperClientWs.mostRecentRequest,
19416           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
19417       assertTrue(GrouperClientWs.mostRecentRequest,
19418           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
19419       assertTrue(GrouperClientWs.mostRecentRequest,
19420           GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
19421           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
19422       assertTrue(GrouperClientWs.mostRecentRequest,
19423           GrouperClientWs.mostRecentRequest.contains("roleLookups")
19424           && GrouperClientWs.mostRecentRequest.contains(group.getUuid()));
19425       assertTrue(GrouperClientWs.mostRecentRequest,
19426           !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
19427 
19428       // ######################################################
19429       // Try ownerGroupUuid
19430 
19431       baos = new ByteArrayOutputStream();
19432       System.setOut(new PrintStream(baos));
19433 
19434       GrouperClient.main(GrouperClientUtils.splitTrim(
19435           "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=assign_permission " +
19436           "--permissionDefNameNames=test:testAttributeAssignDefName --roleIdIndexes=" + group.getIdIndex(),
19437           " "));
19438 
19439       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
19440 
19441       System.out.flush();
19442       output = new String(baos.toByteArray());
19443 
19444       System.setOut(systemOut);
19445 
19446       outputLines = GrouperClientUtils.splitTrim(output, "\n");
19447 
19448       outputLine = outputLines[0];
19449 
19450       matcher = pattern.matcher(outputLines[0]);
19451 
19452       assertTrue(outputLine, matcher.matches());
19453       assertEquals(outputLine, "0", matcher.group(1));
19454       assertEquals(outputLine, "role", matcher.group(2));
19455       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
19456       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
19457       assertEquals(outputLine, "assign", matcher.group(5));
19458 
19459       assertEquals(outputLine, "F", matcher.group(6));
19460       assertEquals(outputLine, "T", matcher.group(7));
19461       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
19462       assertEquals(outputLine, "F", matcher.group(9));
19463 
19464 
19465       assertTrue(GrouperClientWs.mostRecentRequest,
19466           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
19467       assertTrue(GrouperClientWs.mostRecentRequest,
19468           !GrouperClientWs.mostRecentRequest.contains("actions"));
19469       assertTrue(GrouperClientWs.mostRecentRequest,
19470           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
19471       assertTrue(GrouperClientWs.mostRecentRequest,
19472           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
19473       assertTrue(GrouperClientWs.mostRecentRequest,
19474           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
19475       assertTrue(GrouperClientWs.mostRecentRequest,
19476           GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
19477       assertTrue(GrouperClientWs.mostRecentRequest,
19478           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
19479       assertTrue(GrouperClientWs.mostRecentRequest,
19480           GrouperClientWs.mostRecentRequest.contains("permissionType"));
19481       assertTrue(GrouperClientWs.mostRecentRequest,
19482           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
19483       assertTrue(GrouperClientWs.mostRecentRequest,
19484           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
19485       assertTrue(GrouperClientWs.mostRecentRequest,
19486           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
19487       assertTrue(GrouperClientWs.mostRecentRequest,
19488           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
19489       assertTrue(GrouperClientWs.mostRecentRequest,
19490           !GrouperClientWs.mostRecentRequest.contains("params"));
19491       assertTrue(GrouperClientWs.mostRecentRequest,
19492           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
19493       assertTrue(GrouperClientWs.mostRecentRequest,
19494           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
19495       assertTrue(GrouperClientWs.mostRecentRequest,
19496           GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
19497           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
19498       assertTrue(GrouperClientWs.mostRecentRequest,
19499           GrouperClientWs.mostRecentRequest.contains("roleLookups")
19500           && GrouperClientWs.mostRecentRequest.contains(group.getIdIndex().toString()));
19501       assertTrue(GrouperClientWs.mostRecentRequest,
19502           !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
19503 
19504       // ######################################################
19505       // Try enabledTime
19506 
19507       baos = new ByteArrayOutputStream();
19508       System.setOut(new PrintStream(baos));
19509 
19510       GrouperClient.main(GrouperClientUtils.splitTrim(
19511           "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=assign_permission " +
19512           "--permissionDefNameNames=test:testAttributeAssignDefName --roleNames=test:groupTestAttrAssign "
19513           + " --assignmentEnabledTime=2010/03/05_17:05:13.123",
19514           " "));
19515 
19516       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
19517 
19518       System.out.flush();
19519       output = new String(baos.toByteArray());
19520 
19521       System.setOut(systemOut);
19522 
19523       outputLines = GrouperClientUtils.splitTrim(output, "\n");
19524 
19525       outputLine = outputLines[0];
19526 
19527       matcher = pattern.matcher(outputLines[0]);
19528 
19529       assertTrue(outputLine, matcher.matches());
19530       assertEquals(outputLine, "0", matcher.group(1));
19531       assertEquals(outputLine, "role", matcher.group(2));
19532       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
19533       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
19534       assertEquals(outputLine, "assign", matcher.group(5));
19535 
19536       assertEquals(outputLine, "F", matcher.group(6));
19537       assertEquals(outputLine, "T", matcher.group(7));
19538       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
19539       assertEquals(outputLine, "T", matcher.group(9));
19540 
19541 
19542       assertTrue(GrouperClientWs.mostRecentRequest,
19543           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
19544       assertTrue(GrouperClientWs.mostRecentRequest,
19545           !GrouperClientWs.mostRecentRequest.contains("actions"));
19546       assertTrue(GrouperClientWs.mostRecentRequest,
19547           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
19548       assertTrue(GrouperClientWs.mostRecentRequest,
19549           GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime")
19550           && GrouperClientWs.mostRecentRequest.contains("2010/03/05 17:05:13.123"));
19551       assertTrue(GrouperClientWs.mostRecentResponse,
19552           GrouperClientWs.mostRecentResponse.contains("2010/03/05 17:05:13.123"));
19553       assertTrue(GrouperClientWs.mostRecentRequest,
19554           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
19555       assertTrue(GrouperClientWs.mostRecentRequest,
19556           GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
19557       assertTrue(GrouperClientWs.mostRecentRequest,
19558           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
19559       assertTrue(GrouperClientWs.mostRecentRequest,
19560           GrouperClientWs.mostRecentRequest.contains("permissionType"));
19561       assertTrue(GrouperClientWs.mostRecentRequest,
19562           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
19563       assertTrue(GrouperClientWs.mostRecentRequest,
19564           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
19565       assertTrue(GrouperClientWs.mostRecentRequest,
19566           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
19567       assertTrue(GrouperClientWs.mostRecentRequest,
19568           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
19569       assertTrue(GrouperClientWs.mostRecentRequest,
19570           !GrouperClientWs.mostRecentRequest.contains("params"));
19571       assertTrue(GrouperClientWs.mostRecentRequest,
19572           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
19573       assertTrue(GrouperClientWs.mostRecentRequest,
19574           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
19575       assertTrue(GrouperClientWs.mostRecentRequest,
19576           GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
19577           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
19578       assertTrue(GrouperClientWs.mostRecentRequest,
19579           GrouperClientWs.mostRecentRequest.contains("roleLookups")
19580           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
19581       assertTrue(GrouperClientWs.mostRecentRequest,
19582           !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
19583 
19584       // ######################################################
19585       // Try disabledTime
19586 
19587       baos = new ByteArrayOutputStream();
19588       System.setOut(new PrintStream(baos));
19589 
19590       GrouperClient.main(GrouperClientUtils.splitTrim(
19591           "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=assign_permission " +
19592           "--permissionDefNameNames=test:testAttributeAssignDefName --roleNames=test:groupTestAttrAssign "
19593           + " --assignmentDisabledTime=2010/03/05_17:05:13.123",
19594           " "));
19595 
19596       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
19597 
19598       System.out.flush();
19599       output = new String(baos.toByteArray());
19600 
19601       System.setOut(systemOut);
19602 
19603       outputLines = GrouperClientUtils.splitTrim(output, "\n");
19604 
19605       outputLine = outputLines[0];
19606 
19607       matcher = pattern.matcher(outputLines[0]);
19608 
19609       assertTrue(outputLine, matcher.matches());
19610       assertEquals(outputLine, "0", matcher.group(1));
19611       assertEquals(outputLine, "role", matcher.group(2));
19612       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
19613       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
19614       assertEquals(outputLine, "assign", matcher.group(5));
19615 
19616       assertEquals(outputLine, "F", matcher.group(6));
19617       assertEquals(outputLine, "F", matcher.group(7));
19618       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
19619       assertEquals(outputLine, "T", matcher.group(9));
19620 
19621 
19622       assertTrue(GrouperClientWs.mostRecentRequest,
19623           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
19624       assertTrue(GrouperClientWs.mostRecentRequest,
19625           !GrouperClientWs.mostRecentRequest.contains("actions"));
19626       assertTrue(GrouperClientWs.mostRecentRequest,
19627           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
19628       assertTrue(GrouperClientWs.mostRecentRequest,
19629           GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime")
19630           && GrouperClientWs.mostRecentRequest.contains("2010/03/05 17:05:13.123"));
19631       assertTrue(GrouperClientWs.mostRecentResponse,
19632           GrouperClientWs.mostRecentResponse.contains("2010/03/05 17:05:13.123"));
19633       assertTrue(GrouperClientWs.mostRecentRequest,
19634           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
19635       assertTrue(GrouperClientWs.mostRecentRequest,
19636           GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
19637       assertTrue(GrouperClientWs.mostRecentRequest,
19638           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
19639       assertTrue(GrouperClientWs.mostRecentRequest,
19640           GrouperClientWs.mostRecentRequest.contains("permissionType"));
19641       assertTrue(GrouperClientWs.mostRecentRequest,
19642           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
19643       assertTrue(GrouperClientWs.mostRecentRequest,
19644           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
19645       assertTrue(GrouperClientWs.mostRecentRequest,
19646           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
19647       assertTrue(GrouperClientWs.mostRecentRequest,
19648           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
19649       assertTrue(GrouperClientWs.mostRecentRequest,
19650           !GrouperClientWs.mostRecentRequest.contains("params"));
19651       assertTrue(GrouperClientWs.mostRecentRequest,
19652           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
19653       assertTrue(GrouperClientWs.mostRecentRequest,
19654           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
19655       assertTrue(GrouperClientWs.mostRecentRequest,
19656           GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
19657           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
19658       assertTrue(GrouperClientWs.mostRecentRequest,
19659           GrouperClientWs.mostRecentRequest.contains("roleLookups")
19660           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
19661       assertTrue(GrouperClientWs.mostRecentRequest,
19662           !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
19663 
19664       // ######################################################
19665       // Try assignmentNotes
19666 
19667       baos = new ByteArrayOutputStream();
19668       System.setOut(new PrintStream(baos));
19669 
19670       GrouperClient.main(GrouperClientUtils.splitTrim(
19671           "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=assign_permission " +
19672           "--permissionDefNameNames=test:testAttributeAssignDefName --roleNames=test:groupTestAttrAssign "
19673           + " --assignmentNotes=theNotes",
19674           " "));
19675 
19676       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
19677 
19678       System.out.flush();
19679       output = new String(baos.toByteArray());
19680 
19681       System.setOut(systemOut);
19682 
19683       outputLines = GrouperClientUtils.splitTrim(output, "\n");
19684 
19685       outputLine = outputLines[0];
19686 
19687       matcher = pattern.matcher(outputLines[0]);
19688 
19689       assertTrue(outputLine, matcher.matches());
19690       assertEquals(outputLine, "0", matcher.group(1));
19691       assertEquals(outputLine, "role", matcher.group(2));
19692       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
19693       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
19694       assertEquals(outputLine, "assign", matcher.group(5));
19695 
19696       assertEquals(outputLine, "F", matcher.group(6));
19697       assertEquals(outputLine, "T", matcher.group(7));
19698       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
19699       assertEquals(outputLine, "T", matcher.group(9));
19700 
19701 
19702       assertTrue(GrouperClientWs.mostRecentRequest,
19703           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
19704       assertTrue(GrouperClientWs.mostRecentRequest,
19705           !GrouperClientWs.mostRecentRequest.contains("actions"));
19706       assertTrue(GrouperClientWs.mostRecentRequest,
19707           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
19708       assertTrue(GrouperClientWs.mostRecentRequest,
19709           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
19710       assertTrue(GrouperClientWs.mostRecentResponse,
19711           GrouperClientWs.mostRecentResponse.contains("theNotes"));
19712       assertTrue(GrouperClientWs.mostRecentRequest,
19713           GrouperClientWs.mostRecentRequest.contains("assignmentNotes")
19714           && GrouperClientWs.mostRecentRequest.contains("theNotes") );
19715       assertTrue(GrouperClientWs.mostRecentRequest,
19716           GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
19717       assertTrue(GrouperClientWs.mostRecentRequest,
19718           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
19719       assertTrue(GrouperClientWs.mostRecentRequest,
19720           GrouperClientWs.mostRecentRequest.contains("permissionType"));
19721       assertTrue(GrouperClientWs.mostRecentRequest,
19722           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
19723       assertTrue(GrouperClientWs.mostRecentRequest,
19724           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
19725       assertTrue(GrouperClientWs.mostRecentRequest,
19726           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
19727       assertTrue(GrouperClientWs.mostRecentRequest,
19728           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
19729       assertTrue(GrouperClientWs.mostRecentRequest,
19730           !GrouperClientWs.mostRecentRequest.contains("params"));
19731       assertTrue(GrouperClientWs.mostRecentRequest,
19732           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
19733       assertTrue(GrouperClientWs.mostRecentRequest,
19734           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
19735       assertTrue(GrouperClientWs.mostRecentRequest,
19736           GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
19737           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
19738       assertTrue(GrouperClientWs.mostRecentRequest,
19739           GrouperClientWs.mostRecentRequest.contains("roleLookups")
19740           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
19741       assertTrue(GrouperClientWs.mostRecentRequest,
19742           !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
19743 
19744 
19745       // ######################################################
19746       // Try delegatable
19747 
19748       baos = new ByteArrayOutputStream();
19749       System.setOut(new PrintStream(baos));
19750 
19751       GrouperClient.main(GrouperClientUtils.splitTrim(
19752           "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=assign_permission " +
19753           "--permissionDefNameNames=test:testAttributeAssignDefName --roleNames=test:groupTestAttrAssign "
19754           + " --delegatable=FALSE",
19755           " "));
19756 
19757       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
19758 
19759       System.out.flush();
19760       output = new String(baos.toByteArray());
19761 
19762       System.setOut(systemOut);
19763 
19764       outputLines = GrouperClientUtils.splitTrim(output, "\n");
19765 
19766       outputLine = outputLines[0];
19767 
19768       matcher = pattern.matcher(outputLines[0]);
19769 
19770       assertTrue(outputLine, matcher.matches());
19771       assertEquals(outputLine, "0", matcher.group(1));
19772       assertEquals(outputLine, "role", matcher.group(2));
19773       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
19774       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
19775       assertEquals(outputLine, "assign", matcher.group(5));
19776 
19777       assertEquals(outputLine, "F", matcher.group(6));
19778       assertEquals(outputLine, "T", matcher.group(7));
19779       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
19780       assertEquals(outputLine, "T", matcher.group(9));
19781 
19782 
19783       assertTrue(GrouperClientWs.mostRecentRequest,
19784           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
19785       assertTrue(GrouperClientWs.mostRecentRequest,
19786           !GrouperClientWs.mostRecentRequest.contains("actions"));
19787       assertTrue(GrouperClientWs.mostRecentRequest,
19788           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
19789       assertTrue(GrouperClientWs.mostRecentRequest,
19790           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
19791       //assertTrue(GrouperClientWs.mostRecentResponse,
19792       //    GrouperClientWs.mostRecentResponse.contains("theNotes"));
19793       assertTrue(GrouperClientWs.mostRecentRequest,
19794           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
19795       assertTrue(GrouperClientWs.mostRecentRequest,
19796           GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
19797       assertTrue(GrouperClientWs.mostRecentRequest,
19798           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
19799       assertTrue(GrouperClientWs.mostRecentRequest,
19800           GrouperClientWs.mostRecentRequest.contains("permissionType"));
19801       assertTrue(GrouperClientWs.mostRecentRequest,
19802           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
19803       assertTrue(GrouperClientWs.mostRecentRequest,
19804           GrouperClientWs.mostRecentRequest.contains("delegatable")
19805           && GrouperClientWs.mostRecentRequest.contains("FALSE"));
19806       assertTrue(GrouperClientWs.mostRecentRequest,
19807           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
19808       assertTrue(GrouperClientWs.mostRecentRequest,
19809           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
19810       assertTrue(GrouperClientWs.mostRecentRequest,
19811           !GrouperClientWs.mostRecentRequest.contains("params"));
19812       assertTrue(GrouperClientWs.mostRecentRequest,
19813           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
19814       assertTrue(GrouperClientWs.mostRecentRequest,
19815           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
19816       assertTrue(GrouperClientWs.mostRecentRequest,
19817           GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
19818           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
19819       assertTrue(GrouperClientWs.mostRecentRequest,
19820           GrouperClientWs.mostRecentRequest.contains("roleLookups")
19821           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
19822       assertTrue(GrouperClientWs.mostRecentRequest,
19823           !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
19824 
19825       // ######################################################
19826       // Try actions
19827 
19828       baos = new ByteArrayOutputStream();
19829       System.setOut(new PrintStream(baos));
19830 
19831       GrouperClient.main(GrouperClientUtils.splitTrim(
19832           "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=assign_permission " +
19833           "--permissionDefNameNames=test:testAttributeAssignDefName --roleNames=test:groupTestAttrAssign "
19834           + " --actions=assign",
19835           " "));
19836 
19837       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
19838 
19839       System.out.flush();
19840       output = new String(baos.toByteArray());
19841 
19842       System.setOut(systemOut);
19843 
19844       outputLines = GrouperClientUtils.splitTrim(output, "\n");
19845 
19846       outputLine = outputLines[0];
19847 
19848       matcher = pattern.matcher(outputLines[0]);
19849 
19850       assertTrue(outputLine, matcher.matches());
19851       assertEquals(outputLine, "0", matcher.group(1));
19852       assertEquals(outputLine, "role", matcher.group(2));
19853       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
19854       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
19855       assertEquals(outputLine, "assign", matcher.group(5));
19856 
19857       assertEquals(outputLine, "F", matcher.group(6));
19858       assertEquals(outputLine, "T", matcher.group(7));
19859       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
19860       assertEquals(outputLine, "F", matcher.group(9));
19861 
19862 
19863       assertTrue(GrouperClientWs.mostRecentRequest,
19864           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
19865       assertTrue(GrouperClientWs.mostRecentRequest,
19866           GrouperClientWs.mostRecentRequest.contains("actions"));
19867       assertTrue(GrouperClientWs.mostRecentRequest,
19868           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
19869       assertTrue(GrouperClientWs.mostRecentRequest,
19870           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
19871       //assertTrue(GrouperClientWs.mostRecentResponse,
19872       //    GrouperClientWs.mostRecentResponse.contains("theNotes"));
19873       assertTrue(GrouperClientWs.mostRecentRequest,
19874           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
19875       assertTrue(GrouperClientWs.mostRecentRequest,
19876           GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
19877       assertTrue(GrouperClientWs.mostRecentRequest,
19878           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
19879       assertTrue(GrouperClientWs.mostRecentRequest,
19880           GrouperClientWs.mostRecentRequest.contains("permissionType"));
19881       assertTrue(GrouperClientWs.mostRecentRequest,
19882           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
19883       assertTrue(GrouperClientWs.mostRecentRequest,
19884           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
19885       assertTrue(GrouperClientWs.mostRecentRequest,
19886           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
19887       assertTrue(GrouperClientWs.mostRecentRequest,
19888           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
19889       assertTrue(GrouperClientWs.mostRecentRequest,
19890           !GrouperClientWs.mostRecentRequest.contains("params"));
19891       assertTrue(GrouperClientWs.mostRecentRequest,
19892           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
19893       assertTrue(GrouperClientWs.mostRecentRequest,
19894           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
19895       assertTrue(GrouperClientWs.mostRecentRequest,
19896           GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
19897           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
19898       assertTrue(GrouperClientWs.mostRecentRequest,
19899           GrouperClientWs.mostRecentRequest.contains("roleLookups")
19900           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
19901       assertTrue(GrouperClientWs.mostRecentRequest,
19902           !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
19903 
19904       // ######################################################
19905       // includeGroupDetail
19906 
19907       baos = new ByteArrayOutputStream();
19908       System.setOut(new PrintStream(baos));
19909 
19910       GrouperClient.main(GrouperClientUtils.splitTrim(
19911           "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=assign_permission " +
19912           "--permissionDefNameNames=test:testAttributeAssignDefName --roleNames=test:groupTestAttrAssign "
19913           + " --includeGroupDetail=T",
19914           " "));
19915 
19916       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
19917 
19918       System.out.flush();
19919       output = new String(baos.toByteArray());
19920 
19921       System.setOut(systemOut);
19922 
19923       outputLines = GrouperClientUtils.splitTrim(output, "\n");
19924 
19925       outputLine = outputLines[0];
19926 
19927       matcher = pattern.matcher(outputLines[0]);
19928 
19929       assertTrue(outputLine, matcher.matches());
19930       assertEquals(outputLine, "0", matcher.group(1));
19931       assertEquals(outputLine, "role", matcher.group(2));
19932       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
19933       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
19934       assertEquals(outputLine, "assign", matcher.group(5));
19935       assertEquals(outputLine, "F", matcher.group(6));
19936       assertEquals(outputLine, "T", matcher.group(7));
19937       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
19938       assertEquals(outputLine, "F", matcher.group(9));
19939 
19940 
19941       assertTrue(GrouperClientWs.mostRecentRequest,
19942           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
19943       assertTrue(GrouperClientWs.mostRecentRequest,
19944           !GrouperClientWs.mostRecentRequest.contains("actions"));
19945       assertTrue(GrouperClientWs.mostRecentRequest,
19946           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
19947       assertTrue(GrouperClientWs.mostRecentRequest,
19948           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
19949       assertTrue(GrouperClientWs.mostRecentRequest,
19950           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
19951       assertTrue(GrouperClientWs.mostRecentRequest,
19952           GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
19953       assertTrue(GrouperClientWs.mostRecentRequest,
19954           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
19955       assertTrue(GrouperClientWs.mostRecentRequest,
19956           GrouperClientWs.mostRecentRequest.contains("permissionType"));
19957       assertTrue(GrouperClientWs.mostRecentRequest,
19958           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
19959       assertTrue(GrouperClientWs.mostRecentRequest,
19960           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
19961       assertTrue(GrouperClientWs.mostRecentRequest,
19962           GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
19963       assertTrue(GrouperClientWs.mostRecentRequest,
19964           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
19965       assertTrue(GrouperClientWs.mostRecentRequest,
19966           !GrouperClientWs.mostRecentRequest.contains("params"));
19967       assertTrue(GrouperClientWs.mostRecentRequest,
19968           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
19969       assertTrue(GrouperClientWs.mostRecentRequest,
19970           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
19971       assertTrue(GrouperClientWs.mostRecentRequest,
19972           GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
19973           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
19974       assertTrue(GrouperClientWs.mostRecentRequest,
19975           GrouperClientWs.mostRecentRequest.contains("roleLookups")
19976           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
19977       assertTrue(GrouperClientWs.mostRecentRequest,
19978           !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
19979 
19980 
19981       // ######################################################
19982       // includeSubjectDetail
19983 
19984       baos = new ByteArrayOutputStream();
19985       System.setOut(new PrintStream(baos));
19986 
19987       GrouperClient.main(GrouperClientUtils.splitTrim(
19988           "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=assign_permission " +
19989           "--permissionDefNameNames=test:testAttributeAssignDefName --roleNames=test:groupTestAttrAssign "
19990           + " --includeSubjectDetail=T",
19991           " "));
19992 
19993       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
19994 
19995       System.out.flush();
19996       output = new String(baos.toByteArray());
19997 
19998       System.setOut(systemOut);
19999 
20000       outputLines = GrouperClientUtils.splitTrim(output, "\n");
20001 
20002       outputLine = outputLines[0];
20003 
20004       matcher = pattern.matcher(outputLines[0]);
20005 
20006       assertTrue(outputLine, matcher.matches());
20007       assertEquals(outputLine, "0", matcher.group(1));
20008       assertEquals(outputLine, "role", matcher.group(2));
20009       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
20010       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
20011       assertEquals(outputLine, "assign", matcher.group(5));
20012       assertEquals(outputLine, "F", matcher.group(6));
20013       assertEquals(outputLine, "T", matcher.group(7));
20014       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
20015       assertEquals(outputLine, "F", matcher.group(9));
20016 
20017 
20018       assertTrue(GrouperClientWs.mostRecentRequest,
20019           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
20020       assertTrue(GrouperClientWs.mostRecentRequest,
20021           !GrouperClientWs.mostRecentRequest.contains("actions"));
20022       assertTrue(GrouperClientWs.mostRecentRequest,
20023           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
20024       assertTrue(GrouperClientWs.mostRecentRequest,
20025           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
20026       assertTrue(GrouperClientWs.mostRecentRequest,
20027           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
20028       assertTrue(GrouperClientWs.mostRecentRequest,
20029           GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
20030       assertTrue(GrouperClientWs.mostRecentRequest,
20031           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
20032       assertTrue(GrouperClientWs.mostRecentRequest,
20033           GrouperClientWs.mostRecentRequest.contains("permissionType"));
20034       assertTrue(GrouperClientWs.mostRecentRequest,
20035           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
20036       assertTrue(GrouperClientWs.mostRecentRequest,
20037           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
20038       assertTrue(GrouperClientWs.mostRecentRequest,
20039           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
20040       assertTrue(GrouperClientWs.mostRecentRequest,
20041           GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
20042       assertTrue(GrouperClientWs.mostRecentRequest,
20043           !GrouperClientWs.mostRecentRequest.contains("params"));
20044       assertTrue(GrouperClientWs.mostRecentRequest,
20045           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
20046       assertTrue(GrouperClientWs.mostRecentRequest,
20047           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
20048       assertTrue(GrouperClientWs.mostRecentRequest,
20049           GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
20050           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
20051       assertTrue(GrouperClientWs.mostRecentRequest,
20052           GrouperClientWs.mostRecentRequest.contains("roleLookups")
20053           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
20054       assertTrue(GrouperClientWs.mostRecentRequest,
20055           !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
20056 
20057 
20058       // ######################################################
20059       // subjectAttributeNames
20060 
20061       baos = new ByteArrayOutputStream();
20062       System.setOut(new PrintStream(baos));
20063 
20064       GrouperClient.main(GrouperClientUtils.splitTrim(
20065           "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=assign_permission " +
20066           "--permissionDefNameNames=test:testAttributeAssignDefName --roleNames=test:groupTestAttrAssign "
20067           + " --subjectAttributeNames=abc",
20068           " "));
20069 
20070       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
20071 
20072       System.out.flush();
20073       output = new String(baos.toByteArray());
20074 
20075       System.setOut(systemOut);
20076 
20077       outputLines = GrouperClientUtils.splitTrim(output, "\n");
20078 
20079       outputLine = outputLines[0];
20080 
20081       matcher = pattern.matcher(outputLines[0]);
20082 
20083       assertTrue(outputLine, matcher.matches());
20084       assertEquals(outputLine, "0", matcher.group(1));
20085       assertEquals(outputLine, "role", matcher.group(2));
20086       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
20087       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
20088       assertEquals(outputLine, "assign", matcher.group(5));
20089       assertEquals(outputLine, "F", matcher.group(6));
20090       assertEquals(outputLine, "T", matcher.group(7));
20091       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
20092       assertEquals(outputLine, "F", matcher.group(9));
20093 
20094 
20095       assertTrue(GrouperClientWs.mostRecentRequest,
20096           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
20097       assertTrue(GrouperClientWs.mostRecentRequest,
20098           !GrouperClientWs.mostRecentRequest.contains("actions"));
20099       assertTrue(GrouperClientWs.mostRecentRequest,
20100           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
20101       assertTrue(GrouperClientWs.mostRecentRequest,
20102           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
20103       assertTrue(GrouperClientWs.mostRecentRequest,
20104           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
20105       assertTrue(GrouperClientWs.mostRecentRequest,
20106           GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
20107       assertTrue(GrouperClientWs.mostRecentRequest,
20108           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
20109       assertTrue(GrouperClientWs.mostRecentRequest,
20110           GrouperClientWs.mostRecentRequest.contains("permissionType"));
20111       assertTrue(GrouperClientWs.mostRecentRequest,
20112           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
20113       assertTrue(GrouperClientWs.mostRecentRequest,
20114           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
20115       assertTrue(GrouperClientWs.mostRecentRequest,
20116           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
20117       assertTrue(GrouperClientWs.mostRecentRequest,
20118           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
20119       assertTrue(GrouperClientWs.mostRecentRequest,
20120           !GrouperClientWs.mostRecentRequest.contains("params"));
20121       assertTrue(GrouperClientWs.mostRecentRequest,
20122           GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
20123       assertTrue(GrouperClientWs.mostRecentRequest,
20124           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
20125       assertTrue(GrouperClientWs.mostRecentRequest,
20126           GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
20127           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
20128       assertTrue(GrouperClientWs.mostRecentRequest,
20129           GrouperClientWs.mostRecentRequest.contains("roleLookups")
20130           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
20131       assertTrue(GrouperClientWs.mostRecentRequest,
20132           !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
20133 
20134 
20135       // ######################################################
20136       // params
20137 
20138       baos = new ByteArrayOutputStream();
20139       System.setOut(new PrintStream(baos));
20140 
20141       GrouperClient.main(GrouperClientUtils.splitTrim(
20142           "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=assign_permission " +
20143           "--permissionDefNameNames=test:testAttributeAssignDefName --roleNames=test:groupTestAttrAssign "
20144           + " --paramName0=a --paramValue0=b",
20145           " "));
20146 
20147       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
20148 
20149       System.out.flush();
20150       output = new String(baos.toByteArray());
20151 
20152       System.setOut(systemOut);
20153 
20154       outputLines = GrouperClientUtils.splitTrim(output, "\n");
20155 
20156       outputLine = outputLines[0];
20157 
20158       matcher = pattern.matcher(outputLines[0]);
20159 
20160       assertTrue(outputLine, matcher.matches());
20161       assertEquals(outputLine, "0", matcher.group(1));
20162       assertEquals(outputLine, "role", matcher.group(2));
20163       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
20164       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
20165       assertEquals(outputLine, "assign", matcher.group(5));
20166       assertEquals(outputLine, "F", matcher.group(6));
20167       assertEquals(outputLine, "T", matcher.group(7));
20168       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
20169       assertEquals(outputLine, "F", matcher.group(9));
20170 
20171 
20172       assertTrue(GrouperClientWs.mostRecentRequest,
20173           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
20174       assertTrue(GrouperClientWs.mostRecentRequest,
20175           !GrouperClientWs.mostRecentRequest.contains("actions"));
20176       assertTrue(GrouperClientWs.mostRecentRequest,
20177           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
20178       assertTrue(GrouperClientWs.mostRecentRequest,
20179           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
20180       assertTrue(GrouperClientWs.mostRecentRequest,
20181           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
20182       assertTrue(GrouperClientWs.mostRecentRequest,
20183           GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
20184       assertTrue(GrouperClientWs.mostRecentRequest,
20185           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
20186       assertTrue(GrouperClientWs.mostRecentRequest,
20187           GrouperClientWs.mostRecentRequest.contains("permissionType"));
20188       assertTrue(GrouperClientWs.mostRecentRequest,
20189           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
20190       assertTrue(GrouperClientWs.mostRecentRequest,
20191           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
20192       assertTrue(GrouperClientWs.mostRecentRequest,
20193           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
20194       assertTrue(GrouperClientWs.mostRecentRequest,
20195           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
20196       assertTrue(GrouperClientWs.mostRecentRequest,
20197           GrouperClientWs.mostRecentRequest.contains("params"));
20198       assertTrue(GrouperClientWs.mostRecentRequest,
20199           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
20200       assertTrue(GrouperClientWs.mostRecentRequest,
20201           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
20202       assertTrue(GrouperClientWs.mostRecentRequest,
20203           GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
20204           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
20205       assertTrue(GrouperClientWs.mostRecentRequest,
20206           GrouperClientWs.mostRecentRequest.contains("roleLookups")
20207           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
20208       assertTrue(GrouperClientWs.mostRecentRequest,
20209           !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
20210 
20211 
20212       // ######################################################
20213       // attribute assign lookups
20214 
20215       baos = new ByteArrayOutputStream();
20216       System.setOut(new PrintStream(baos));
20217 
20218       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
20219 
20220       String attributeAssignId = attributeAssign.getId();
20221 
20222       GrouperClient.main(GrouperClientUtils.splitTrim(
20223           "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=remove_permission "
20224           + " --attributeAssignUuids=" + attributeAssign.getId(),
20225           " "));
20226 
20227       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, false);
20228 
20229       assertNull("Should be deleted", attributeAssign);
20230 
20231       System.out.flush();
20232       output = new String(baos.toByteArray());
20233 
20234       System.setOut(systemOut);
20235 
20236       outputLines = GrouperClientUtils.splitTrim(output, "\n");
20237 
20238       outputLine = outputLines[0];
20239 
20240       matcher = pattern.matcher(outputLines[0]);
20241 
20242       assertTrue(outputLine, matcher.matches());
20243       assertEquals(outputLine, "0", matcher.group(1));
20244       assertEquals(outputLine, "role", matcher.group(2));
20245       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
20246       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
20247       assertEquals(outputLine, "assign", matcher.group(5));
20248 
20249       assertEquals(outputLine, "F", matcher.group(6));
20250       assertEquals(outputLine, "T", matcher.group(7));
20251       assertEquals(outputLine, attributeAssignId, matcher.group(8));
20252       assertEquals(outputLine, "T", matcher.group(9));
20253 
20254 
20255       assertTrue(GrouperClientWs.mostRecentRequest,
20256           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
20257       assertTrue(GrouperClientWs.mostRecentRequest,
20258           !GrouperClientWs.mostRecentRequest.contains("actions"));
20259       assertTrue(GrouperClientWs.mostRecentRequest,
20260           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
20261       assertTrue(GrouperClientWs.mostRecentRequest,
20262           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
20263       assertTrue(GrouperClientWs.mostRecentRequest,
20264           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
20265       assertTrue(GrouperClientWs.mostRecentRequest,
20266           GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
20267       assertTrue(GrouperClientWs.mostRecentRequest,
20268           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
20269       assertTrue(GrouperClientWs.mostRecentRequest,
20270           GrouperClientWs.mostRecentRequest.contains("permissionType"));
20271       assertTrue(GrouperClientWs.mostRecentRequest,
20272           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
20273       assertTrue(GrouperClientWs.mostRecentRequest,
20274           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
20275       assertTrue(GrouperClientWs.mostRecentRequest,
20276           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
20277       assertTrue(GrouperClientWs.mostRecentRequest,
20278           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
20279       assertTrue(GrouperClientWs.mostRecentRequest,
20280           !GrouperClientWs.mostRecentRequest.contains("params"));
20281       assertTrue(GrouperClientWs.mostRecentRequest,
20282           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
20283       assertTrue(GrouperClientWs.mostRecentRequest,
20284           GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
20285       assertTrue(GrouperClientWs.mostRecentRequest,
20286           !GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
20287           && !GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
20288       assertTrue(GrouperClientWs.mostRecentRequest,
20289           !GrouperClientWs.mostRecentRequest.contains("roleLookups")
20290           && !GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
20291       assertTrue(GrouperClientWs.mostRecentRequest,
20292           !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
20293 
20294       // ######################################################
20295       // attribute assign lookups custom tempflate
20296 
20297       baos = new ByteArrayOutputStream();
20298       System.setOut(new PrintStream(baos));
20299 
20300       attributeAssign = group.getAttributeDelegate().assignAttribute(attributeDefName).getAttributeAssign();
20301 
20302       attributeAssignId = attributeAssign.getId();
20303 
20304       GrouperClient.main(GrouperClientUtils.splitTrim(
20305           "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=remove_permission "
20306           + " --attributeAssignUuids=" + attributeAssign.getId() + " --outputTemplate=${wsAttributeAssign.attributeAssignType}$newline$",
20307           " "));
20308 
20309       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, false);
20310 
20311       assertNull("Should be deleted", attributeAssign);
20312 
20313       System.out.flush();
20314       output = new String(baos.toByteArray());
20315 
20316       System.setOut(systemOut);
20317 
20318       outputLines = GrouperClientUtils.splitTrim(output, "\n");
20319 
20320       outputLine = GrouperClientUtils.trim(outputLines[0]);
20321 
20322       assertEquals(outputLine, "group", outputLine);
20323 
20324       assertTrue(GrouperClientWs.mostRecentRequest,
20325           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
20326       assertTrue(GrouperClientWs.mostRecentRequest,
20327           !GrouperClientWs.mostRecentRequest.contains("actions"));
20328       assertTrue(GrouperClientWs.mostRecentRequest,
20329           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
20330       assertTrue(GrouperClientWs.mostRecentRequest,
20331           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
20332       assertTrue(GrouperClientWs.mostRecentRequest,
20333           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
20334       assertTrue(GrouperClientWs.mostRecentRequest,
20335           GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
20336       assertTrue(GrouperClientWs.mostRecentRequest,
20337           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
20338       assertTrue(GrouperClientWs.mostRecentRequest,
20339           GrouperClientWs.mostRecentRequest.contains("permissionType"));
20340       assertTrue(GrouperClientWs.mostRecentRequest,
20341           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
20342       assertTrue(GrouperClientWs.mostRecentRequest,
20343           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
20344       assertTrue(GrouperClientWs.mostRecentRequest,
20345           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
20346       assertTrue(GrouperClientWs.mostRecentRequest,
20347           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
20348       assertTrue(GrouperClientWs.mostRecentRequest,
20349           !GrouperClientWs.mostRecentRequest.contains("params"));
20350       assertTrue(GrouperClientWs.mostRecentRequest,
20351           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
20352       assertTrue(GrouperClientWs.mostRecentRequest,
20353           GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
20354       assertTrue(GrouperClientWs.mostRecentRequest,
20355           !GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
20356           && !GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
20357       assertTrue(GrouperClientWs.mostRecentRequest,
20358           !GrouperClientWs.mostRecentRequest.contains("roleLookups")
20359           && !GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
20360       assertTrue(GrouperClientWs.mostRecentRequest,
20361           !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
20362 
20363 
20364       // ######################################################
20365       // attribute assign lookups
20366 
20367       baos = new ByteArrayOutputStream();
20368       System.setOut(new PrintStream(baos));
20369 
20370       attributeAssign = group.getAttributeDelegate().assignAttribute(attributeDefName).getAttributeAssign();
20371 
20372       attributeAssignId = attributeAssign.getId();
20373 
20374       GrouperClient.main(GrouperClientUtils.splitTrim(
20375           "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=remove_permission "
20376           + " --attributeAssignUuids=" + attributeAssign.getId() + " --actAsSubjectId=GrouperSystem",
20377           " "));
20378 
20379       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, false);
20380 
20381       assertNull("Should be deleted", attributeAssign);
20382 
20383       System.out.flush();
20384       output = new String(baos.toByteArray());
20385 
20386       System.setOut(systemOut);
20387 
20388       outputLines = GrouperClientUtils.splitTrim(output, "\n");
20389 
20390       outputLine = outputLines[0];
20391 
20392       matcher = pattern.matcher(outputLines[0]);
20393 
20394       assertTrue(outputLine, matcher.matches());
20395       assertEquals(outputLine, "0", matcher.group(1));
20396       assertEquals(outputLine, "role", matcher.group(2));
20397       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
20398       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
20399       assertEquals(outputLine, "assign", matcher.group(5));
20400 
20401       assertEquals(outputLine, "F", matcher.group(6));
20402       assertEquals(outputLine, "T", matcher.group(7));
20403       assertEquals(outputLine, attributeAssignId, matcher.group(8));
20404       assertEquals(outputLine, "T", matcher.group(9));
20405 
20406 
20407       assertTrue(GrouperClientWs.mostRecentRequest,
20408           GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
20409       assertTrue(GrouperClientWs.mostRecentRequest,
20410           !GrouperClientWs.mostRecentRequest.contains("actions"));
20411       assertTrue(GrouperClientWs.mostRecentRequest,
20412           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
20413       assertTrue(GrouperClientWs.mostRecentRequest,
20414           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
20415       assertTrue(GrouperClientWs.mostRecentRequest,
20416           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
20417       assertTrue(GrouperClientWs.mostRecentRequest,
20418           GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
20419       assertTrue(GrouperClientWs.mostRecentRequest,
20420           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
20421       assertTrue(GrouperClientWs.mostRecentRequest,
20422           GrouperClientWs.mostRecentRequest.contains("permissionType"));
20423       assertTrue(GrouperClientWs.mostRecentRequest,
20424           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
20425       assertTrue(GrouperClientWs.mostRecentRequest,
20426           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
20427       assertTrue(GrouperClientWs.mostRecentRequest,
20428           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
20429       assertTrue(GrouperClientWs.mostRecentRequest,
20430           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
20431       assertTrue(GrouperClientWs.mostRecentRequest,
20432           !GrouperClientWs.mostRecentRequest.contains("params"));
20433       assertTrue(GrouperClientWs.mostRecentRequest,
20434           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
20435       assertTrue(GrouperClientWs.mostRecentRequest,
20436           GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
20437       assertTrue(GrouperClientWs.mostRecentRequest,
20438           !GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
20439           && !GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
20440       assertTrue(GrouperClientWs.mostRecentRequest,
20441           !GrouperClientWs.mostRecentRequest.contains("roleLookups")
20442           && !GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
20443       assertTrue(GrouperClientWs.mostRecentRequest,
20444           !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
20445 
20446       // ######################################################
20447       // disallow
20448 
20449       baos = new ByteArrayOutputStream();
20450       System.setOut(new PrintStream(baos));
20451 
20452       group.getAttributeDelegate().removeAttribute(attributeDefName);
20453 
20454       GrouperClient.main(GrouperClientUtils.splitTrim(
20455           "--operation=assignPermissionsWs --permissionType=role --permissionAssignOperation=assign_permission " +
20456           "--permissionDefNameNames=test:testAttributeAssignDefName --roleNames=test:groupTestAttrAssign --disallowed=true",
20457           " "));
20458 
20459       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, false);
20460       attributeAssignId = attributeAssign.getId();
20461 
20462       assertTrue("Should be disallowed", attributeAssign.isDisallowed());
20463 
20464       System.out.flush();
20465       output = new String(baos.toByteArray());
20466 
20467       System.setOut(systemOut);
20468 
20469       outputLines = GrouperClientUtils.splitTrim(output, "\n");
20470 
20471       outputLine = outputLines[0];
20472 
20473       matcher = pattern.matcher(outputLines[0]);
20474 
20475       assertTrue(outputLine, matcher.matches());
20476       assertEquals(outputLine, "0", matcher.group(1));
20477       assertEquals(outputLine, "role", matcher.group(2));
20478       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
20479       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
20480       assertEquals(outputLine, "assign", matcher.group(5));
20481 
20482       assertEquals(outputLine, "T", matcher.group(6));
20483       assertEquals(outputLine, "T", matcher.group(7));
20484       assertEquals(outputLine, attributeAssignId, matcher.group(8));
20485       assertEquals(outputLine, "T", matcher.group(9));
20486 
20487 
20488       assertTrue(GrouperClientWs.mostRecentRequest,
20489           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
20490       assertTrue(GrouperClientWs.mostRecentRequest,
20491           !GrouperClientWs.mostRecentRequest.contains("actions"));
20492       assertTrue(GrouperClientWs.mostRecentRequest,
20493           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
20494       assertTrue(GrouperClientWs.mostRecentRequest,
20495           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
20496       assertTrue(GrouperClientWs.mostRecentRequest,
20497           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
20498       assertTrue(GrouperClientWs.mostRecentRequest,
20499           GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
20500       assertTrue(GrouperClientWs.mostRecentRequest,
20501           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
20502       assertTrue(GrouperClientWs.mostRecentRequest,
20503           GrouperClientWs.mostRecentRequest.contains("permissionType"));
20504       assertTrue(GrouperClientWs.mostRecentRequest,
20505           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
20506       assertTrue(GrouperClientWs.mostRecentRequest,
20507           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
20508       assertTrue(GrouperClientWs.mostRecentRequest,
20509           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
20510       assertTrue(GrouperClientWs.mostRecentRequest,
20511           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
20512       assertTrue(GrouperClientWs.mostRecentRequest,
20513           !GrouperClientWs.mostRecentRequest.contains("params"));
20514       assertTrue(GrouperClientWs.mostRecentRequest,
20515           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
20516       assertTrue(GrouperClientWs.mostRecentRequest,
20517           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
20518       assertTrue(GrouperClientWs.mostRecentRequest,
20519           GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
20520           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
20521       assertTrue(GrouperClientWs.mostRecentRequest,
20522           GrouperClientWs.mostRecentRequest.contains("roleLookups")
20523           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
20524       assertTrue(GrouperClientWs.mostRecentRequest,
20525           !GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups"));
20526       assertTrue(GrouperClientWs.mostRecentRequest,
20527           GrouperClientWs.mostRecentRequest.contains("disallowed"));
20528 
20529 
20530 
20531     } finally {
20532       System.setOut(systemOut);
20533     }
20534 
20535   }
20536 
20537   /**
20538    * @throws Exception
20539    */
20540   public void testAssignPermissionsAnyMembership() throws Exception {
20541 
20542     GrouperSession grouperSession = GrouperSession.startRootSession();
20543 
20544     AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb(AttributeDefType.perm, "test", "testAttributeAssignDefName");
20545 
20546     final AttributeDef attributeDef = attributeDefName.getAttributeDef();
20547 
20548     attributeDef.setAssignToGroup(false);
20549     attributeDef.setAssignToEffMembership(true);
20550     attributeDef.store();
20551 
20552     Group group1 = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
20553       .assignGroupNameToEdit("test:anyMembershipTestAttrAssign").assignName("test:anyMembershipTestAttrAssign").assignCreateParentStemsIfNotExist(true)
20554       .assignTypeOfGroup(TypeOfGroup.role).assignDescription("description").save();
20555 
20556     Group group2 = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
20557       .assignGroupNameToEdit("test:anyMembershipTestAttrAssign2").assignName("test:anyMembershipTestAttrAssign2").assignCreateParentStemsIfNotExist(true)
20558       .assignDescription("description").save();
20559 
20560     //add one group to another to make effective membership and add attribute to that membership
20561     group1.addMember(group2.toSubject());
20562     group2.addMember(SubjectTestHelper.SUBJ0);
20563 
20564     Member member = MemberFinder.findBySubject(grouperSession, SubjectTestHelper.SUBJ0, false);
20565 
20566     Membership membership = (Membership)MembershipFinder.findMemberships(GrouperUtil.toSet(group1.getId()),
20567         GrouperUtil.toSet(member.getUuid()), null, null, FieldFinder.find("members", true), null, null, null, null, null).iterator().next()[0];
20568 
20569 
20570     AttributeAssign attributeAssign = null;
20571 
20572     PrintStream systemOut = System.out;
20573 
20574     ByteArrayOutputStream baos = new ByteArrayOutputStream();
20575     System.setOut(new PrintStream(baos));
20576 
20577     try {
20578 
20579       GrouperClient.main(GrouperClientUtils.splitTrim(
20580           "--operation=assignPermissionsWs --permissionType=role_subject --permissionAssignOperation=assign_permission " +
20581           "--permissionDefNameNames=test:testAttributeAssignDefName --subjectRole0SubjectId=" + member.getSubjectId()
20582           + " --subjectRole0RoleName=" + group1.getName(),
20583           " "));
20584 
20585       attributeAssign = membership.getAttributeDelegateEffMship().retrieveAssignment("assign", attributeDefName, false, true);
20586 
20587       System.out.flush();
20588       String output = new String(baos.toByteArray());
20589 
20590       System.setOut(systemOut);
20591 
20592       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
20593 
20594       // match: Index: 0: attributeAssignType: group, owner: test:groupTestAttrAssign, attributeDefNameNameName test:testAttributeAssignDefName, action: assign, values: 15,5,5, enable: T, id: a9c83eeb78c04ae5befcea36272d318c, changed: true, valuesChanged: false
20595       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F), changed\: (T|F), valuesChanged\: (T|F)$
20596       Pattern pattern = Pattern
20597         .compile("^Index\\: (\\d+)\\: permissionType\\: (.+), owner\\: (.+), permissionDefNameName\\: (.+), action\\: (.+), disallowed\\: (T|F), enabled\\: (T|F), attributeAssignId\\: (.+), changed\\: (T|F), deleted\\: (T|F)$");
20598       String outputLine = outputLines[0];
20599 
20600       Matcher matcher = pattern.matcher(outputLines[0]);
20601 
20602       assertTrue(outputLine, matcher.matches());
20603       assertEquals(outputLine, "0", matcher.group(1));
20604       assertEquals(outputLine, "role_subject", matcher.group(2));
20605       assertEquals(outputLine, "test:anyMembershipTestAttrAssign - jdbc - test.subject.0", matcher.group(3));
20606       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
20607       assertEquals(outputLine, "assign", matcher.group(5));
20608 
20609       assertEquals(outputLine, "F", matcher.group(6));
20610       assertEquals(outputLine, "T", matcher.group(7));
20611       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
20612       assertEquals(outputLine, "T", matcher.group(9));
20613 
20614       assertTrue(GrouperClientWs.mostRecentRequest,
20615           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
20616       assertTrue(GrouperClientWs.mostRecentRequest,
20617           !GrouperClientWs.mostRecentRequest.contains("actions"));
20618       assertTrue(GrouperClientWs.mostRecentRequest,
20619           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
20620       assertTrue(GrouperClientWs.mostRecentRequest,
20621           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
20622       assertTrue(GrouperClientWs.mostRecentRequest,
20623           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
20624       assertTrue(GrouperClientWs.mostRecentRequest,
20625           GrouperClientWs.mostRecentRequest.contains("permissionAssignOperation"));
20626       assertTrue(GrouperClientWs.mostRecentRequest,
20627           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
20628       assertTrue(GrouperClientWs.mostRecentRequest,
20629           GrouperClientWs.mostRecentRequest.contains("permissionType"));
20630       assertTrue(GrouperClientWs.mostRecentRequest,
20631           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
20632       assertTrue(GrouperClientWs.mostRecentRequest,
20633           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
20634       assertTrue(GrouperClientWs.mostRecentRequest,
20635           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
20636       assertTrue(GrouperClientWs.mostRecentRequest,
20637           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
20638       assertTrue(GrouperClientWs.mostRecentRequest,
20639           !GrouperClientWs.mostRecentRequest.contains("params"));
20640       assertTrue(GrouperClientWs.mostRecentRequest,
20641           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
20642       assertTrue(GrouperClientWs.mostRecentRequest,
20643           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
20644       assertTrue(GrouperClientWs.mostRecentRequest,
20645           GrouperClientWs.mostRecentRequest.contains("permissionDefNameLookups")
20646           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
20647       assertTrue(GrouperClientWs.mostRecentRequest,
20648           !GrouperClientWs.mostRecentRequest.contains("roleLookups")
20649           && !GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
20650       assertTrue(GrouperClientWs.mostRecentRequest,
20651           GrouperClientWs.mostRecentRequest.contains("subjectRoleLookups")
20652           && GrouperClientWs.mostRecentRequest.contains(group1.getName())
20653           && GrouperClientWs.mostRecentRequest.contains(member.getSubjectId()));
20654 
20655 
20656     } finally {
20657       System.setOut(systemOut);
20658     }
20659 
20660   }
20661 
20662   /**
20663    *
20664    * @throws Exception
20665    */
20666   public void atestGetGroupsCache() throws Exception {
20667 
20668     // make sure group exists
20669     GrouperSession grouperSession = GrouperSession.startRootSession();
20670     Group group = Group.saveGroup(grouperSession, "aStem:aGroup", null,
20671         "aStem:aGroup", "aGroup", "description1", null, true);
20672 
20673     String wsUserLabel = GrouperClientUtils.propertiesValue(
20674         "grouperClient.webService.user.label", true);
20675     String wsUserString = GrouperClientUtils.propertiesValue(
20676         "grouperClient.webService." + wsUserLabel, true);
20677     Subject wsUser = SubjectFinder.findByIdOrIdentifier(wsUserString, true);
20678 
20679     group.grantPriv(wsUser, AccessPrivilege.READ, false);
20680     group.grantPriv(wsUser, AccessPrivilege.VIEW, false);
20681 
20682     // add a subject
20683     group.addMember(SubjectTestHelper.SUBJ0, false);
20684 
20685     WsGetGroupsResults wsGetGroupsResults = new GcGetGroups().addSubjectId(SubjectTestHelper.SUBJ0_ID).execute();
20686 
20687     assertEquals("description1", wsGetGroupsResults.getResults()[0].getWsGroups()[0].getDescription());
20688 
20689     //change the description
20690     WsGroupToSave wsGroupToSave = new WsGroupToSave();
20691     wsGroupToSave.setWsGroupLookup(new WsGroupLookup("aStem:aGroup", null));
20692     WsGroup wsGroup = new WsGroup();
20693     wsGroup.setDescription("description2");
20694     wsGroup.setName("aStem:aGroup");
20695     wsGroup.setDisplayExtension("aGroup");
20696     wsGroupToSave.setWsGroup(wsGroup);
20697     WsGroupSaveResults wsGroupSaveResults = new GcGroupSave().addGroupToSave(wsGroupToSave).execute();
20698     assertEquals("description2", wsGroupSaveResults.getResults()[0].getWsGroup().getDescription());
20699 
20700     //get groups for user again
20701     wsGetGroupsResults = new GcGetGroups().addSubjectId(SubjectTestHelper.SUBJ0_ID).execute();
20702 
20703     assertEquals("description2", wsGetGroupsResults.getResults()[0].getWsGroups()[0].getDescription());
20704 
20705 
20706   }
20707 
20708   /**
20709    * @throws Exception
20710    */
20711   public void testAttributeDefNameSave() throws Exception {
20712 
20713     PrintStream systemOut = System.out;
20714 
20715     ByteArrayOutputStream baos = new ByteArrayOutputStream();
20716     System.setOut(new PrintStream(baos));
20717     String output = null;
20718     String[] outputLines = null;
20719     Pattern pattern = null;
20720     Matcher matcher = null;
20721     try {
20722 
20723       GrouperSession grouperSession = GrouperSession.startRootSession();
20724 
20725       AttributeDef attributeDef = new AttributeDefSave(grouperSession).assignName("aStem:newAttributeDef")
20726         .assignCreateParentStemsIfNotExist(true).save();
20727 
20728       GrouperClient.main(GrouperClientUtils.splitTrim(
20729           "--operation=attributeDefNameSaveWs --name=aStem:newAttributeDefName --nameOfAttributeDef=aStem:newAttributeDef", " "));
20730       System.out.flush();
20731       output = new String(baos.toByteArray());
20732 
20733       systemOut.println(output);
20734 
20735       System.setOut(systemOut);
20736 
20737       outputLines = GrouperClientUtils.splitTrim(output, "\n");
20738 
20739       assertEquals(1, outputLines.length);
20740 
20741       pattern = Pattern.compile("^Success: (T|F): code: ([A-Z_]+): (.*+)$");
20742       matcher = pattern.matcher(outputLines[0]);
20743 
20744       assertTrue(outputLines[0], matcher.matches());
20745 
20746       assertEquals(outputLines[0], "T", matcher.group(1));
20747       assertEquals(outputLines[0], "SUCCESS_INSERTED", matcher.group(2));
20748       assertEquals(outputLines[0], "aStem:newAttributeDefName", matcher.group(3));
20749 
20750       // ##########################
20751       //try with name with slash
20752 
20753       baos = new ByteArrayOutputStream();
20754       System.setOut(new PrintStream(baos));
20755 
20756       GrouperClient.main(GrouperClientUtils.splitTrim(
20757           "--operation=attributeDefNameSaveWs --name=aStem:newAttributeDefName0/1 --nameOfAttributeDef=aStem:newAttributeDef", " "));
20758       System.out.flush();
20759       output = new String(baos.toByteArray());
20760 
20761       System.setOut(systemOut);
20762 
20763       outputLines = GrouperClientUtils.splitTrim(output, "\n");
20764 
20765       assertEquals(1, outputLines.length);
20766 
20767       matcher = pattern.matcher(outputLines[0]);
20768 
20769       assertTrue(outputLines[0], matcher.matches());
20770 
20771       assertEquals(outputLines[0], "T", matcher.group(1));
20772       assertEquals(outputLines[0], "SUCCESS_INSERTED", matcher.group(2));
20773       assertEquals(outputLines[0], "aStem:newAttributeDefName0/1", matcher.group(3));
20774 
20775       assertFalse(GrouperClientWs.mostRecentRequest,
20776           GrouperClientWs.mostRecentRequest.contains("saveMode"));
20777 
20778       //########################################################
20779       // run again with save mode  --saveMode=INSERT_OR_UPDATE|INSERT|UPDATE
20780 
20781       baos = new ByteArrayOutputStream();
20782       System.setOut(new PrintStream(baos));
20783 
20784       GrouperClient.main(GrouperClientUtils.splitTrim(
20785           "--operation=attributeDefNameSaveWs --name=aStem:newAttributeDefName0/1 --nameOfAttributeDef=aStem:newAttributeDef --saveMode=UPDATE", " "));
20786       System.out.flush();
20787       output = new String(baos.toByteArray());
20788 
20789       System.setOut(systemOut);
20790 
20791       outputLines = GrouperClientUtils.splitTrim(output, "\n");
20792 
20793       assertEquals(1, outputLines.length);
20794 
20795       matcher = pattern.matcher(outputLines[0]);
20796 
20797       assertTrue(outputLines[0], matcher.matches());
20798 
20799       assertEquals(outputLines[0], "T", matcher.group(1));
20800       assertEquals(outputLines[0], "SUCCESS_NO_CHANGES_NEEDED", matcher.group(2));
20801       assertEquals(outputLines[0], "aStem:newAttributeDefName0/1", matcher.group(3));
20802 
20803       assertTrue(GrouperClientWs.mostRecentRequest,
20804         GrouperClientWs.mostRecentRequest.contains("saveMode")
20805             && GrouperClientWs.mostRecentRequest.contains(">UPDATE<"));
20806       assertFalse(GrouperClientWs.mostRecentRequest,
20807           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookup"));
20808 
20809       //########################################################
20810       // run again with lookup  --attributeDefNameLookupName=aStem:newAttributeDefName
20811 
20812       baos = new ByteArrayOutputStream();
20813       System.setOut(new PrintStream(baos));
20814 
20815       GrouperClient.main(GrouperClientUtils.splitTrim(
20816           "--operation=attributeDefNameSaveWs --name=aStem:newAttributeDefName --attributeDefNameLookupName=aStem:newAttributeDefName --nameOfAttributeDef=aStem:newAttributeDef", " "));
20817       System.out.flush();
20818       output = new String(baos.toByteArray());
20819 
20820       System.setOut(systemOut);
20821 
20822       outputLines = GrouperClientUtils.splitTrim(output, "\n");
20823 
20824       assertEquals(1, outputLines.length);
20825 
20826       matcher = pattern.matcher(outputLines[0]);
20827 
20828       assertTrue(outputLines[0], matcher.matches());
20829 
20830       assertEquals(outputLines[0], "T", matcher.group(1));
20831       assertEquals(outputLines[0], "SUCCESS_NO_CHANGES_NEEDED", matcher.group(2));
20832       assertEquals(outputLines[0], "aStem:newAttributeDefName", matcher.group(3));
20833 
20834       assertFalse(GrouperClientWs.mostRecentRequest,
20835         GrouperClientWs.mostRecentRequest.contains("saveMode"));
20836       assertTrue(GrouperClientWs.mostRecentRequest,
20837           GrouperClientWs.mostRecentRequest.contains("<wsAttributeDefNameLookup>"));
20838 
20839 
20840       //########################################################
20841       // run again with lookup  --attributeDefNameLookupUuid=aStem:newAttributeDefName
20842 
20843       AttributeDefName newAttributeDefName = AttributeDefNameFinder.findByName("aStem:newAttributeDefName", true);
20844 
20845       baos = new ByteArrayOutputStream();
20846       System.setOut(new PrintStream(baos));
20847 
20848       GrouperClient.main(GrouperClientUtils.splitTrim(
20849           "--operation=attributeDefNameSaveWs --name=aStem:newAttributeDefName --attributeDefNameLookupUuid=" + newAttributeDefName.getId() + " --nameOfAttributeDef=aStem:newAttributeDef", " "));
20850       System.out.flush();
20851       output = new String(baos.toByteArray());
20852 
20853       System.setOut(systemOut);
20854 
20855       outputLines = GrouperClientUtils.splitTrim(output, "\n");
20856 
20857       assertEquals(1, outputLines.length);
20858 
20859       matcher = pattern.matcher(outputLines[0]);
20860 
20861       assertTrue(outputLines[0], matcher.matches());
20862 
20863       assertEquals(outputLines[0], "T", matcher.group(1));
20864       assertEquals(outputLines[0], "SUCCESS_NO_CHANGES_NEEDED", matcher.group(2));
20865       assertEquals(outputLines[0], "aStem:newAttributeDefName", matcher.group(3));
20866 
20867       assertFalse(GrouperClientWs.mostRecentRequest,
20868         GrouperClientWs.mostRecentRequest.contains("description"));
20869       assertTrue(GrouperClientWs.mostRecentRequest,
20870           GrouperClientWs.mostRecentRequest.contains("<wsAttributeDefNameLookup>")
20871           && GrouperClientWs.mostRecentRequest.contains(newAttributeDefName.getId()));
20872 
20873       //########################################################
20874       // run again with lookup  --attributeDefNameLookupUuid=aStem:newAttributeDefName
20875 
20876       baos = new ByteArrayOutputStream();
20877       System.setOut(new PrintStream(baos));
20878 
20879       GrouperClient.main(GrouperClientUtils.splitTrim(
20880           "--operation=attributeDefNameSaveWs --name=aStem:newAttributeDefName --attributeDefNameLookupIdIndex=" + newAttributeDefName.getIdIndex() + " --nameOfAttributeDef=aStem:newAttributeDef", " "));
20881       System.out.flush();
20882       output = new String(baos.toByteArray());
20883 
20884       System.setOut(systemOut);
20885 
20886       outputLines = GrouperClientUtils.splitTrim(output, "\n");
20887 
20888       assertEquals(1, outputLines.length);
20889 
20890       matcher = pattern.matcher(outputLines[0]);
20891 
20892       assertTrue(outputLines[0], matcher.matches());
20893 
20894       assertEquals(outputLines[0], "T", matcher.group(1));
20895       assertEquals(outputLines[0], "SUCCESS_NO_CHANGES_NEEDED", matcher.group(2));
20896       assertEquals(outputLines[0], "aStem:newAttributeDefName", matcher.group(3));
20897 
20898       assertFalse(GrouperClientWs.mostRecentRequest,
20899         GrouperClientWs.mostRecentRequest.contains("description"));
20900       assertTrue(GrouperClientWs.mostRecentRequest,
20901           GrouperClientWs.mostRecentRequest.contains("<wsAttributeDefNameLookup>")
20902           && GrouperClientWs.mostRecentRequest.contains(newAttributeDefName.getIdIndex().toString()));
20903 
20904       //########################################################
20905       // run again with --description=theDescription
20906 
20907       baos = new ByteArrayOutputStream();
20908       System.setOut(new PrintStream(baos));
20909 
20910       GrouperClient.main(GrouperClientUtils.splitTrim(
20911           "--operation=attributeDefNameSaveWs --name=aStem:newAttributeDefName --description=theDescription --nameOfAttributeDef=aStem:newAttributeDef", " "));
20912       System.out.flush();
20913       output = new String(baos.toByteArray());
20914 
20915       System.setOut(systemOut);
20916 
20917       outputLines = GrouperClientUtils.splitTrim(output, "\n");
20918 
20919       assertEquals(1, outputLines.length);
20920 
20921       matcher = pattern.matcher(outputLines[0]);
20922 
20923       assertTrue(outputLines[0], matcher.matches());
20924 
20925       assertEquals(outputLines[0], "T", matcher.group(1));
20926       assertEquals(outputLines[0], "SUCCESS_UPDATED", matcher.group(2));
20927       assertEquals(outputLines[0], "aStem:newAttributeDefName", matcher.group(3));
20928 
20929       assertTrue(GrouperClientWs.mostRecentRequest,
20930           GrouperClientWs.mostRecentRequest.contains("<description>")
20931           && GrouperClientWs.mostRecentRequest.contains("theDescription"));
20932 
20933       //########################################################
20934       // run again with --idIndex=12345
20935 
20936       baos = new ByteArrayOutputStream();
20937       System.setOut(new PrintStream(baos));
20938 
20939       GrouperClient.main(GrouperClientUtils.splitTrim(
20940           "--operation=attributeDefNameSaveWs --name=aStem:newAttributeDefName5 --idIndex=12345 --nameOfAttributeDef=aStem:newAttributeDef", " "));
20941       System.out.flush();
20942       output = new String(baos.toByteArray());
20943 
20944       System.setOut(systemOut);
20945 
20946       outputLines = GrouperClientUtils.splitTrim(output, "\n");
20947 
20948       assertEquals(1, outputLines.length);
20949 
20950       matcher = pattern.matcher(outputLines[0]);
20951 
20952       assertTrue(outputLines[0], matcher.matches());
20953 
20954       assertEquals(outputLines[0], "T", matcher.group(1));
20955       assertEquals(outputLines[0], "SUCCESS_INSERTED", matcher.group(2));
20956       assertEquals(outputLines[0], "aStem:newAttributeDefName5", matcher.group(3));
20957 
20958       assertTrue(GrouperClientWs.mostRecentRequest,
20959           GrouperClientWs.mostRecentRequest.contains("<idIndex>")
20960           && GrouperClientWs.mostRecentRequest.contains("12345"));
20961       assertTrue(GrouperClientWs.mostRecentResponse,
20962           GrouperClientWs.mostRecentResponse.contains("<idIndex>12345"));
20963 
20964       //########################################################
20965       // run again with --displayExtension=theDisplayExtension
20966 
20967       baos = new ByteArrayOutputStream();
20968       System.setOut(new PrintStream(baos));
20969 
20970       GrouperClient.main(GrouperClientUtils.splitTrim(
20971           "--operation=attributeDefNameSaveWs --name=aStem:newAttributeDefName --displayExtension=theDisplayExtension --nameOfAttributeDef=aStem:newAttributeDef", " "));
20972       System.out.flush();
20973       output = new String(baos.toByteArray());
20974 
20975       System.setOut(systemOut);
20976 
20977       outputLines = GrouperClientUtils.splitTrim(output, "\n");
20978 
20979       assertEquals(1, outputLines.length);
20980 
20981       matcher = pattern.matcher(outputLines[0]);
20982 
20983       assertTrue(outputLines[0], matcher.matches());
20984 
20985       assertEquals(outputLines[0], "T", matcher.group(1));
20986       assertEquals(outputLines[0], "SUCCESS_UPDATED", matcher.group(2));
20987       assertEquals(outputLines[0], "aStem:newAttributeDefName", matcher.group(3));
20988 
20989       assertFalse(GrouperClientWs.mostRecentRequest,
20990           GrouperClientWs.mostRecentRequest.contains("createParentStemsIfNotExist"));
20991       assertTrue(GrouperClientWs.mostRecentRequest,
20992           GrouperClientWs.mostRecentRequest.contains("<displayExtension>")
20993           && GrouperClientWs.mostRecentRequest.contains("theDisplayExtension"));
20994 
20995       //########################################################
20996       // run again with --createParentStemsIfNotExist=true
20997 
20998       baos = new ByteArrayOutputStream();
20999       System.setOut(new PrintStream(baos));
21000 
21001       GrouperClient.main(GrouperClientUtils.splitTrim(
21002           "--operation=attributeDefNameSaveWs --name=aStem:newAttributeDefName --createParentStemsIfNotExist=true --nameOfAttributeDef=aStem:newAttributeDef", " "));
21003       System.out.flush();
21004       output = new String(baos.toByteArray());
21005 
21006       System.setOut(systemOut);
21007 
21008       outputLines = GrouperClientUtils.splitTrim(output, "\n");
21009 
21010       assertEquals(1, outputLines.length);
21011 
21012       matcher = pattern.matcher(outputLines[0]);
21013 
21014       assertTrue(outputLines[0], matcher.matches());
21015 
21016       assertEquals(outputLines[0], "T", matcher.group(1));
21017       assertEquals(outputLines[0], "SUCCESS_UPDATED", matcher.group(2));
21018       assertEquals(outputLines[0], "aStem:newAttributeDefName", matcher.group(3));
21019 
21020       assertFalse(GrouperClientWs.mostRecentRequest,
21021           GrouperClientWs.mostRecentRequest.contains("attributeDefId"));
21022       assertTrue(GrouperClientWs.mostRecentRequest,
21023           GrouperClientWs.mostRecentRequest.contains("createParentStemsIfNotExist"));
21024       assertTrue(GrouperClientWs.mostRecentRequest,
21025           GrouperClientWs.mostRecentRequest.contains("<attributeDefName>"));
21026 
21027       //########################################################
21028       // run again with --uuidOfAttributeDef=abc
21029 
21030       baos = new ByteArrayOutputStream();
21031       System.setOut(new PrintStream(baos));
21032 
21033       GrouperClient.main(GrouperClientUtils.splitTrim(
21034           "--operation=attributeDefNameSaveWs --name=aStem:newAttributeDefName --uuidOfAttributeDef=" + attributeDef.getId(), " "));
21035       System.out.flush();
21036       output = new String(baos.toByteArray());
21037 
21038       System.setOut(systemOut);
21039 
21040       outputLines = GrouperClientUtils.splitTrim(output, "\n");
21041 
21042       assertEquals(1, outputLines.length);
21043 
21044       matcher = pattern.matcher(outputLines[0]);
21045 
21046       assertTrue(outputLines[0], matcher.matches());
21047 
21048       assertEquals(outputLines[0], "T", matcher.group(1));
21049       assertEquals(outputLines[0], "SUCCESS_NO_CHANGES_NEEDED", matcher.group(2));
21050       assertEquals(outputLines[0], "aStem:newAttributeDefName", matcher.group(3));
21051 
21052       assertFalse(GrouperClientWs.mostRecentRequest,
21053           GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
21054       assertTrue(GrouperClientWs.mostRecentRequest,
21055           GrouperClientWs.mostRecentRequest.contains("<attributeDefId>"));
21056 
21057 
21058       //########################################################
21059       // run again with --actAsSubjectId=subjId
21060 
21061       baos = new ByteArrayOutputStream();
21062       System.setOut(new PrintStream(baos));
21063 
21064       GrouperClient.main(GrouperClientUtils.splitTrim(
21065           "--operation=attributeDefNameSaveWs --name=aStem:newAttributeDefName --actAsSubjectId=GrouperSystem --nameOfAttributeDef=aStem:newAttributeDef", " "));
21066       System.out.flush();
21067       output = new String(baos.toByteArray());
21068 
21069       System.setOut(systemOut);
21070 
21071       outputLines = GrouperClientUtils.splitTrim(output, "\n");
21072 
21073       assertEquals(1, outputLines.length);
21074 
21075       matcher = pattern.matcher(outputLines[0]);
21076 
21077       assertTrue(outputLines[0], matcher.matches());
21078 
21079       assertEquals(outputLines[0], "T", matcher.group(1));
21080       assertEquals(outputLines[0], "SUCCESS_NO_CHANGES_NEEDED", matcher.group(2));
21081       assertEquals(outputLines[0], "aStem:newAttributeDefName", matcher.group(3));
21082 
21083       assertFalse(GrouperClientWs.mostRecentRequest,
21084           GrouperClientWs.mostRecentRequest.contains("subjectIdentifier"));
21085       assertTrue(GrouperClientWs.mostRecentRequest,
21086           GrouperClientWs.mostRecentRequest.contains("<actAsSubjectLookup><subjectId>"));
21087 
21088 
21089       //########################################################
21090       // run again with --actAsSubjectIdentifier=subjId
21091 
21092       baos = new ByteArrayOutputStream();
21093       System.setOut(new PrintStream(baos));
21094 
21095       GrouperClient.main(GrouperClientUtils.splitTrim(
21096           "--operation=attributeDefNameSaveWs --name=aStem:newAttributeDefName --actAsSubjectIdentifier=GrouperSystem --nameOfAttributeDef=aStem:newAttributeDef", " "));
21097       System.out.flush();
21098       output = new String(baos.toByteArray());
21099 
21100       System.setOut(systemOut);
21101 
21102       outputLines = GrouperClientUtils.splitTrim(output, "\n");
21103 
21104       assertEquals(1, outputLines.length);
21105 
21106       matcher = pattern.matcher(outputLines[0]);
21107 
21108       assertTrue(outputLines[0], matcher.matches());
21109 
21110       assertEquals(outputLines[0], "T", matcher.group(1));
21111       assertEquals(outputLines[0], "SUCCESS_NO_CHANGES_NEEDED", matcher.group(2));
21112       assertEquals(outputLines[0], "aStem:newAttributeDefName", matcher.group(3));
21113 
21114       assertFalse(GrouperClientWs.mostRecentRequest,
21115           GrouperClientWs.mostRecentRequest.contains("sourceId"));
21116       assertTrue(GrouperClientWs.mostRecentRequest,
21117           GrouperClientWs.mostRecentRequest.contains("<actAsSubjectLookup><subjectIdentifier>"));
21118 
21119 
21120       //########################################################
21121       // run again with --actAsSubjectSource=subjId
21122 
21123       baos = new ByteArrayOutputStream();
21124       System.setOut(new PrintStream(baos));
21125 
21126       GrouperClient.main(GrouperClientUtils.splitTrim(
21127           "--operation=attributeDefNameSaveWs --name=aStem:newAttributeDefName --actAsSubjectIdentifier=GrouperSystem --actAsSubjectSource=g:isa --nameOfAttributeDef=aStem:newAttributeDef", " "));
21128       System.out.flush();
21129       output = new String(baos.toByteArray());
21130 
21131       System.setOut(systemOut);
21132 
21133       outputLines = GrouperClientUtils.splitTrim(output, "\n");
21134 
21135       assertEquals(1, outputLines.length);
21136 
21137       matcher = pattern.matcher(outputLines[0]);
21138 
21139       assertTrue(outputLines[0], matcher.matches());
21140 
21141       assertEquals(outputLines[0], "T", matcher.group(1));
21142       assertEquals(outputLines[0], "SUCCESS_NO_CHANGES_NEEDED", matcher.group(2));
21143       assertEquals(outputLines[0], "aStem:newAttributeDefName", matcher.group(3));
21144 
21145       assertFalse(GrouperClientWs.mostRecentRequest,
21146           GrouperClientWs.mostRecentRequest.contains("somethingelse"));
21147       assertTrue(GrouperClientWs.mostRecentRequest,
21148           GrouperClientWs.mostRecentRequest.contains("subjectSourceId")
21149           && GrouperClientWs.mostRecentRequest.contains("g:isa"));
21150 
21151     } finally {
21152       System.setOut(systemOut);
21153     }
21154 
21155   }
21156 
21157   /**
21158    * @throws Exception
21159    */
21160   public void testAttributeDefNameDelete() throws Exception {
21161 
21162     PrintStream systemOut = System.out;
21163 
21164     ByteArrayOutputStream baos = new ByteArrayOutputStream();
21165     System.setOut(new PrintStream(baos));
21166     String output = null;
21167     String[] outputLines = null;
21168     Pattern pattern = null;
21169     Matcher matcher = null;
21170     try {
21171 
21172       GrouperSession grouperSession = GrouperSession.startRootSession();
21173 
21174       AttributeDef attributeDef = new AttributeDefSave(grouperSession).assignName("aStem:newAttributeDef")
21175         .assignCreateParentStemsIfNotExist(true).save();
21176 
21177       AttributeDefName attributeDefName = new AttributeDefNameSave(grouperSession, attributeDef).assignName("aStem:newAttributeDefName")
21178         .assignCreateParentStemsIfNotExist(true).save();
21179 
21180       GrouperClient.main(GrouperClientUtils.splitTrim(
21181           "--operation=attributeDefNameDeleteWs --attributeDefNameNames=aStem:newAttributeDefName,aStem:newAttributeDefName2", " "));
21182       System.out.flush();
21183       output = new String(baos.toByteArray());
21184 
21185       systemOut.println(output);
21186 
21187       System.setOut(systemOut);
21188 
21189       outputLines = GrouperClientUtils.splitTrim(output, "\n");
21190 
21191       assertEquals(2, outputLines.length);
21192 
21193       pattern = Pattern.compile("^Index (\\d+): success: (T|F): code: ([A-Z_]+): (.*+)$");
21194       matcher = pattern.matcher(outputLines[0]);
21195 
21196       assertTrue(outputLines[0], matcher.matches());
21197 
21198       assertEquals(outputLines[0], "0", matcher.group(1));
21199       assertEquals(outputLines[0], "T", matcher.group(2));
21200       assertEquals(outputLines[0], "SUCCESS", matcher.group(3));
21201       assertEquals(outputLines[0], "aStem:newAttributeDefName", matcher.group(4));
21202 
21203       matcher = pattern.matcher(outputLines[1]);
21204 
21205       assertTrue(outputLines[1], matcher.matches());
21206 
21207       assertEquals(outputLines[1], "1", matcher.group(1));
21208       assertEquals(outputLines[1], "T", matcher.group(2));
21209       assertEquals(outputLines[1], "SUCCESS_ATTRIBUTE_DEF_NAME_NOT_FOUND", matcher.group(3));
21210       assertEquals(outputLines[1], "aStem:newAttributeDefName2", matcher.group(4));
21211 
21212       // ##########################
21213       // [--txType=NONE|READ_WRITE_NEW]
21214       baos = new ByteArrayOutputStream();
21215       System.setOut(new PrintStream(baos));
21216 
21217       GrouperClient.main(GrouperClientUtils.splitTrim(
21218           "--operation=attributeDefNameDeleteWs --attributeDefNameNames=aStem:newAttributeDefName,aStem:newAttributeDefName2 --txType=READ_WRITE_NEW", " "));
21219       System.out.flush();
21220       output = new String(baos.toByteArray());
21221 
21222       System.setOut(systemOut);
21223 
21224       outputLines = GrouperClientUtils.splitTrim(output, "\n");
21225 
21226       assertEquals(2, outputLines.length);
21227 
21228       matcher = pattern.matcher(outputLines[0]);
21229 
21230       assertTrue(outputLines[0], matcher.matches());
21231 
21232       assertEquals(outputLines[0], "0", matcher.group(1));
21233       assertEquals(outputLines[0], "T", matcher.group(2));
21234       assertEquals(outputLines[0], "SUCCESS_ATTRIBUTE_DEF_NAME_NOT_FOUND", matcher.group(3));
21235       assertEquals(outputLines[0], "aStem:newAttributeDefName", matcher.group(4));
21236 
21237       matcher = pattern.matcher(outputLines[1]);
21238 
21239       assertTrue(outputLines[1], matcher.matches());
21240 
21241       assertEquals(outputLines[1], "1", matcher.group(1));
21242       assertEquals(outputLines[1], "T", matcher.group(2));
21243       assertEquals(outputLines[1], "SUCCESS_ATTRIBUTE_DEF_NAME_NOT_FOUND", matcher.group(3));
21244       assertEquals(outputLines[1], "aStem:newAttributeDefName2", matcher.group(4));
21245 
21246       assertTrue(GrouperClientWs.mostRecentRequest,
21247           GrouperClientWs.mostRecentRequest.contains("txType") && GrouperClientWs.mostRecentRequest.contains("READ_WRITE_NEW"));
21248 
21249 
21250     } finally {
21251       System.setOut(systemOut);
21252     }
21253 
21254   }
21255 
21256   /**
21257    * @throws Exception
21258    */
21259   public void testFindAttributeDefNames() throws Exception {
21260 
21261     PrintStream systemOut = System.out;
21262 
21263     ByteArrayOutputStream baos = new ByteArrayOutputStream();
21264     System.setOut(new PrintStream(baos));
21265     String output = null;
21266     String[] outputLines = null;
21267     Pattern pattern = null;
21268     Matcher matcher = null;
21269     try {
21270 
21271       GrouperSession grouperSession = GrouperSession.startRootSession();
21272 
21273       AttributeDef attributeDef = new AttributeDefSave(grouperSession).assignName("aStem1:newAttributeDef")
21274         .assignCreateParentStemsIfNotExist(true).assignAttributeDefType(AttributeDefType.perm).assignToGroup(true).save();
21275 
21276       AttributeDefName attributeDefName = new AttributeDefNameSave(grouperSession, attributeDef).assignName("aStem1:newAttributeDefName1")
21277         .assignCreateParentStemsIfNotExist(true).save();
21278 
21279       AttributeDefName attributeDefName2 = new AttributeDefNameSave(grouperSession, attributeDef).assignName("aStem1:newAttributeDefName2")
21280         .assignCreateParentStemsIfNotExist(true).save();
21281 
21282       attributeDefName.getAttributeDefNameSetDelegate().addToAttributeDefNameSet(attributeDefName2);
21283 
21284       AttributeDefName attributeDefName3 = new AttributeDefNameSave(grouperSession, attributeDef).assignName("aStem1:sub:newAttributeDefName3")
21285       .assignCreateParentStemsIfNotExist(true).save();
21286 
21287       AttributeDefName attributeDefName4 = new AttributeDefNameSave(grouperSession, attributeDef).assignName("aStem2:newAttributeDefName4")
21288         .assignCreateParentStemsIfNotExist(true).save();
21289 
21290       GrouperClient.main(GrouperClientUtils.splitTrim(
21291           "--operation=findAttributeDefNamesWs --scope=aStem", " "));
21292       System.out.flush();
21293       output = new String(baos.toByteArray());
21294 
21295       systemOut.println(output);
21296 
21297       System.setOut(systemOut);
21298 
21299       outputLines = GrouperClientUtils.splitTrim(output, "\n");
21300 
21301       assertEquals(4, outputLines.length);
21302 
21303       //Index ${index}: name: ${wsAttributeDefName.name}, displayName: ${wsAttributeDefName.displayName}$newline$
21304       pattern = Pattern.compile("^Index (\\d+): name: (.*), displayName: (.*)$");
21305       matcher = pattern.matcher(outputLines[0]);
21306 
21307       assertTrue(outputLines[0], matcher.matches());
21308 
21309       assertEquals(outputLines[0], "0", matcher.group(1));
21310       assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(2));
21311       assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(3));
21312 
21313       assertTrue(GrouperClientWs.mostRecentRequest,
21314           GrouperClientWs.mostRecentRequest.contains("scope"));
21315       assertFalse(GrouperClientWs.mostRecentRequest,
21316           GrouperClientWs.mostRecentRequest.contains("splitScope"));
21317 
21318       // ############################
21319       //[--splitScope=T|F]
21320       baos = new ByteArrayOutputStream();
21321 
21322       System.setOut(new PrintStream(baos));
21323 
21324       GrouperClient.main(GrouperClientUtils.splitTrim(
21325           "--operation=findAttributeDefNamesWs --scope=aStem --splitScope=T", " "));
21326       System.out.flush();
21327       output = new String(baos.toByteArray());
21328 
21329       systemOut.println(output);
21330 
21331       System.setOut(systemOut);
21332 
21333       outputLines = GrouperClientUtils.splitTrim(output, "\n");
21334 
21335       assertEquals(4, outputLines.length);
21336 
21337       //Index ${index}: name: ${wsAttributeDefName.name}, displayName: ${wsAttributeDefName.displayName}$newline$
21338       matcher = pattern.matcher(outputLines[0]);
21339 
21340       assertTrue(outputLines[0], matcher.matches());
21341 
21342       assertEquals(outputLines[0], "0", matcher.group(1));
21343       assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(2));
21344       assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(3));
21345 
21346       assertTrue(GrouperClientWs.mostRecentRequest,
21347           GrouperClientWs.mostRecentRequest.contains("scope"));
21348       assertTrue(GrouperClientWs.mostRecentRequest,
21349           GrouperClientWs.mostRecentRequest.contains("splitScope"));
21350       assertFalse(GrouperClientWs.mostRecentRequest,
21351           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
21352 
21353       // ############################
21354       //[--attributeDefNameNames=a:b]
21355       baos = new ByteArrayOutputStream();
21356 
21357       System.setOut(new PrintStream(baos));
21358 
21359       GrouperClient.main(GrouperClientUtils.splitTrim(
21360           "--operation=findAttributeDefNamesWs --attributeDefNameNames=aStem1:newAttributeDefName1,aStem1:newAttributeDefName2", " "));
21361       System.out.flush();
21362       output = new String(baos.toByteArray());
21363 
21364       systemOut.println(output);
21365 
21366       System.setOut(systemOut);
21367 
21368       outputLines = GrouperClientUtils.splitTrim(output, "\n");
21369 
21370       assertEquals(2, outputLines.length);
21371 
21372       //Index ${index}: name: ${wsAttributeDefName.name}, displayName: ${wsAttributeDefName.displayName}$newline$
21373       matcher = pattern.matcher(outputLines[0]);
21374 
21375       assertTrue(outputLines[0], matcher.matches());
21376 
21377       assertEquals(outputLines[0], "0", matcher.group(1));
21378       assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(2));
21379       assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(3));
21380 
21381       assertFalse(GrouperClientWs.mostRecentRequest,
21382           GrouperClientWs.mostRecentRequest.contains("scope"));
21383       assertFalse(GrouperClientWs.mostRecentRequest,
21384           GrouperClientWs.mostRecentRequest.contains("splitScope"));
21385       assertTrue(GrouperClientWs.mostRecentRequest,
21386           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
21387 
21388       // ############################
21389       //[--attributeDefNameUuids=12ab,34cd]
21390       baos = new ByteArrayOutputStream();
21391 
21392       System.setOut(new PrintStream(baos));
21393 
21394       GrouperClient.main(GrouperClientUtils.splitTrim(
21395           "--operation=findAttributeDefNamesWs --attributeDefNameUuids=" + attributeDefName.getId() + "," + attributeDefName2.getId(), " "));
21396       System.out.flush();
21397       output = new String(baos.toByteArray());
21398 
21399       systemOut.println(output);
21400 
21401       System.setOut(systemOut);
21402 
21403       outputLines = GrouperClientUtils.splitTrim(output, "\n");
21404 
21405       assertEquals(2, outputLines.length);
21406 
21407       //Index ${index}: name: ${wsAttributeDefName.name}, displayName: ${wsAttributeDefName.displayName}$newline$
21408       matcher = pattern.matcher(outputLines[0]);
21409 
21410       assertTrue(outputLines[0], matcher.matches());
21411 
21412       assertEquals(outputLines[0], "0", matcher.group(1));
21413       assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(2));
21414       assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(3));
21415 
21416       assertFalse(GrouperClientWs.mostRecentRequest,
21417           GrouperClientWs.mostRecentRequest.contains("scope"));
21418       assertFalse(GrouperClientWs.mostRecentRequest,
21419           GrouperClientWs.mostRecentRequest.contains("splitScope"));
21420       assertTrue(GrouperClientWs.mostRecentRequest,
21421           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
21422       assertFalse(GrouperClientWs.mostRecentRequest,
21423           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookup"));
21424 
21425       // ############################
21426       //[--attributeDefNameIdIndexes=12,34]
21427       baos = new ByteArrayOutputStream();
21428 
21429       System.setOut(new PrintStream(baos));
21430 
21431       GrouperClient.main(GrouperClientUtils.splitTrim(
21432           "--operation=findAttributeDefNamesWs --attributeDefNameIdIndexes=" + attributeDefName.getIdIndex() + "," + attributeDefName2.getIdIndex(), " "));
21433       System.out.flush();
21434       output = new String(baos.toByteArray());
21435 
21436       systemOut.println(output);
21437 
21438       System.setOut(systemOut);
21439 
21440       outputLines = GrouperClientUtils.splitTrim(output, "\n");
21441 
21442       assertEquals(2, outputLines.length);
21443 
21444       //Index ${index}: name: ${wsAttributeDefName.name}, displayName: ${wsAttributeDefName.displayName}$newline$
21445       matcher = pattern.matcher(outputLines[0]);
21446 
21447       assertTrue(outputLines[0], matcher.matches());
21448 
21449       assertEquals(outputLines[0], "0", matcher.group(1));
21450       assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(2));
21451       assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(3));
21452 
21453       assertFalse(GrouperClientWs.mostRecentRequest,
21454           GrouperClientWs.mostRecentRequest.contains("scope"));
21455       assertFalse(GrouperClientWs.mostRecentRequest,
21456           GrouperClientWs.mostRecentRequest.contains("splitScope"));
21457       assertTrue(GrouperClientWs.mostRecentRequest,
21458           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
21459       assertFalse(GrouperClientWs.mostRecentRequest,
21460           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookup"));
21461 
21462       // ############################
21463       //[--nameOfAttributeDef=a:b:c]
21464       baos = new ByteArrayOutputStream();
21465 
21466       System.setOut(new PrintStream(baos));
21467 
21468       GrouperClient.main(GrouperClientUtils.splitTrim(
21469           "--operation=findAttributeDefNamesWs --scope=% --nameOfAttributeDef=aStem1:newAttributeDef", " "));
21470       System.out.flush();
21471       output = new String(baos.toByteArray());
21472 
21473       systemOut.println(output);
21474 
21475       System.setOut(systemOut);
21476 
21477       outputLines = GrouperClientUtils.splitTrim(output, "\n");
21478 
21479       assertEquals(4, outputLines.length);
21480 
21481       //Index ${index}: name: ${wsAttributeDefName.name}, displayName: ${wsAttributeDefName.displayName}$newline$
21482       matcher = pattern.matcher(outputLines[0]);
21483 
21484       assertTrue(outputLines[0], matcher.matches());
21485 
21486       assertEquals(outputLines[0], "0", matcher.group(1));
21487       assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(2));
21488       assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(3));
21489 
21490       assertTrue(GrouperClientWs.mostRecentRequest,
21491           GrouperClientWs.mostRecentRequest.contains("scope"));
21492       assertFalse(GrouperClientWs.mostRecentRequest,
21493           GrouperClientWs.mostRecentRequest.contains("splitScope"));
21494       assertTrue(GrouperClientWs.mostRecentRequest,
21495           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookup"));
21496 
21497       // ############################
21498       //[--uuidOfAttributeDef=a:b:c]
21499       baos = new ByteArrayOutputStream();
21500 
21501       System.setOut(new PrintStream(baos));
21502 
21503       GrouperClient.main(GrouperClientUtils.splitTrim(
21504           "--operation=findAttributeDefNamesWs --scope=% --uuidOfAttributeDef=" + attributeDef.getId(), " "));
21505       System.out.flush();
21506       output = new String(baos.toByteArray());
21507 
21508       systemOut.println(output);
21509 
21510       System.setOut(systemOut);
21511 
21512       outputLines = GrouperClientUtils.splitTrim(output, "\n");
21513 
21514       assertEquals(4, outputLines.length);
21515 
21516       //Index ${index}: name: ${wsAttributeDefName.name}, displayName: ${wsAttributeDefName.displayName}$newline$
21517       matcher = pattern.matcher(outputLines[0]);
21518 
21519       assertTrue(outputLines[0], matcher.matches());
21520 
21521       assertEquals(outputLines[0], "0", matcher.group(1));
21522       assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(2));
21523       assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(3));
21524 
21525       assertTrue(GrouperClientWs.mostRecentRequest,
21526           GrouperClientWs.mostRecentRequest.contains("scope"));
21527       assertFalse(GrouperClientWs.mostRecentRequest,
21528           GrouperClientWs.mostRecentRequest.contains("splitScope"));
21529       assertFalse(GrouperClientWs.mostRecentRequest,
21530           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
21531       assertTrue(GrouperClientWs.mostRecentRequest,
21532           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookup"));
21533 
21534       // ############################
21535       //[--idIndexOfAttributeDef=123]
21536       baos = new ByteArrayOutputStream();
21537 
21538       System.setOut(new PrintStream(baos));
21539 
21540       GrouperClient.main(GrouperClientUtils.splitTrim(
21541           "--operation=findAttributeDefNamesWs --scope=% --idIndexOfAttributeDef=" + attributeDef.getIdIndex(), " "));
21542       System.out.flush();
21543       output = new String(baos.toByteArray());
21544 
21545       systemOut.println(output);
21546 
21547       System.setOut(systemOut);
21548 
21549       outputLines = GrouperClientUtils.splitTrim(output, "\n");
21550 
21551       assertEquals(4, outputLines.length);
21552 
21553       //Index ${index}: name: ${wsAttributeDefName.name}, displayName: ${wsAttributeDefName.displayName}$newline$
21554       matcher = pattern.matcher(outputLines[0]);
21555 
21556       assertTrue(outputLines[0], matcher.matches());
21557 
21558       assertEquals(outputLines[0], "0", matcher.group(1));
21559       assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(2));
21560       assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(3));
21561 
21562       assertTrue(GrouperClientWs.mostRecentRequest,
21563           GrouperClientWs.mostRecentRequest.contains("scope"));
21564       assertFalse(GrouperClientWs.mostRecentRequest,
21565           GrouperClientWs.mostRecentRequest.contains("splitScope"));
21566       assertFalse(GrouperClientWs.mostRecentRequest,
21567           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
21568       assertTrue(GrouperClientWs.mostRecentRequest,
21569           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookup"));
21570 
21571       // ############################
21572       //[--attributeAssignType=any_mem|any_mem_asgn|attr_def|attr_def_asgn|group|group_asgn|imm_mem|imm_mem_asgn|mem_asgn|member|stem|stem_asgn]
21573       baos = new ByteArrayOutputStream();
21574 
21575       System.setOut(new PrintStream(baos));
21576 
21577       GrouperClient.main(GrouperClientUtils.splitTrim(
21578           "--operation=findAttributeDefNamesWs --scope=aStem1 --attributeAssignType=stem", " "));
21579       System.out.flush();
21580       output = new String(baos.toByteArray());
21581 
21582       systemOut.println(output);
21583 
21584       System.setOut(systemOut);
21585 
21586       outputLines = GrouperClientUtils.splitTrim(output, "\n");
21587 
21588       assertEquals(0, GrouperUtil.length(outputLines));
21589 
21590       assertTrue(GrouperClientWs.mostRecentRequest,
21591           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
21592 
21593       // ############################
21594       //[--attributeAssignType=any_mem|any_mem_asgn|attr_def|attr_def_asgn|group|group_asgn|imm_mem|imm_mem_asgn|mem_asgn|member|stem|stem_asgn]
21595       baos = new ByteArrayOutputStream();
21596 
21597       System.setOut(new PrintStream(baos));
21598 
21599       GrouperClient.main(GrouperClientUtils.splitTrim(
21600           "--operation=findAttributeDefNamesWs --scope=aStem1 --attributeAssignType=group", " "));
21601       System.out.flush();
21602       output = new String(baos.toByteArray());
21603 
21604       systemOut.println(output);
21605 
21606       System.setOut(systemOut);
21607 
21608       outputLines = GrouperClientUtils.splitTrim(output, "\n");
21609 
21610       assertEquals(3, outputLines.length);
21611 
21612       //Index ${index}: name: ${wsAttributeDefName.name}, displayName: ${wsAttributeDefName.displayName}$newline$
21613       matcher = pattern.matcher(outputLines[0]);
21614 
21615       assertTrue(outputLines[0], matcher.matches());
21616 
21617       assertEquals(outputLines[0], "0", matcher.group(1));
21618       assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(2));
21619       assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(3));
21620 
21621       assertTrue(GrouperClientWs.mostRecentRequest,
21622           GrouperClientWs.mostRecentRequest.contains("scope"));
21623       assertTrue(GrouperClientWs.mostRecentRequest,
21624           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
21625 
21626       // ############################
21627       //[--attributeDefType=attr|domain|limit|perm|type]
21628       baos = new ByteArrayOutputStream();
21629 
21630       System.setOut(new PrintStream(baos));
21631 
21632       GrouperClient.main(GrouperClientUtils.splitTrim(
21633           "--operation=findAttributeDefNamesWs --scope=aStem1 --attributeDefType=attr", " "));
21634       System.out.flush();
21635       output = new String(baos.toByteArray());
21636 
21637       systemOut.println(output);
21638 
21639       System.setOut(systemOut);
21640 
21641       outputLines = GrouperClientUtils.splitTrim(output, "\n");
21642 
21643       assertEquals(0, GrouperUtil.length(outputLines));
21644 
21645       assertTrue(GrouperClientWs.mostRecentRequest,
21646           GrouperClientWs.mostRecentRequest.contains("scope"));
21647       assertFalse(GrouperClientWs.mostRecentRequest,
21648           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
21649       assertTrue(GrouperClientWs.mostRecentRequest,
21650           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
21651 
21652       // ############################
21653       //[--attributeDefType=attr|domain|limit|perm|type]
21654       baos = new ByteArrayOutputStream();
21655 
21656       System.setOut(new PrintStream(baos));
21657 
21658       GrouperClient.main(GrouperClientUtils.splitTrim(
21659           "--operation=findAttributeDefNamesWs --scope=aStem1 --attributeDefType=perm", " "));
21660       System.out.flush();
21661       output = new String(baos.toByteArray());
21662 
21663       systemOut.println(output);
21664 
21665       System.setOut(systemOut);
21666 
21667       outputLines = GrouperClientUtils.splitTrim(output, "\n");
21668 
21669       assertEquals(3, outputLines.length);
21670 
21671       //Index ${index}: name: ${wsAttributeDefName.name}, displayName: ${wsAttributeDefName.displayName}$newline$
21672       matcher = pattern.matcher(outputLines[0]);
21673 
21674       assertTrue(outputLines[0], matcher.matches());
21675 
21676       assertEquals(outputLines[0], "0", matcher.group(1));
21677       assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(2));
21678       assertEquals(outputLines[0], "aStem1:newAttributeDefName1", matcher.group(3));
21679 
21680       assertTrue(GrouperClientWs.mostRecentRequest,
21681           GrouperClientWs.mostRecentRequest.contains("scope"));
21682       assertFalse(GrouperClientWs.mostRecentRequest,
21683           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
21684       assertTrue(GrouperClientWs.mostRecentRequest,
21685           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
21686       assertFalse(GrouperClientWs.mostRecentRequest,
21687           GrouperClientWs.mostRecentRequest.contains("wsInheritanceSetRelation"));
21688 
21689       // ############################
21690       //[--inheritanceSetRelation=IMPLIED_BY_THIS|IMPLIED_BY_THIS_IMMEDIATE|THAT_IMPLY_THIS|THAT_IMPLY_THIS_IMMEDIATE]
21691       baos = new ByteArrayOutputStream();
21692 
21693       System.setOut(new PrintStream(baos));
21694 
21695       GrouperClient.main(GrouperClientUtils.splitTrim(
21696           "--operation=findAttributeDefNamesWs --attributeDefNameNames=aStem1:newAttributeDefName1 --inheritanceSetRelation=IMPLIED_BY_THIS", " "));
21697       System.out.flush();
21698       output = new String(baos.toByteArray());
21699 
21700       systemOut.println(output);
21701 
21702       System.setOut(systemOut);
21703 
21704       outputLines = GrouperClientUtils.splitTrim(output, "\n");
21705 
21706       assertEquals(1, outputLines.length);
21707 
21708       //Index ${index}: name: ${wsAttributeDefName.name}, displayName: ${wsAttributeDefName.displayName}$newline$
21709       matcher = pattern.matcher(outputLines[0]);
21710 
21711       assertTrue(outputLines[0], matcher.matches());
21712 
21713       assertEquals(outputLines[0], "0", matcher.group(1));
21714       assertEquals(outputLines[0], "aStem1:newAttributeDefName2", matcher.group(2));
21715       assertEquals(outputLines[0], "aStem1:newAttributeDefName2", matcher.group(3));
21716 
21717       assertTrue(GrouperClientWs.mostRecentRequest,
21718           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
21719       assertTrue(GrouperClientWs.mostRecentRequest,
21720           GrouperClientWs.mostRecentRequest.contains("wsInheritanceSetRelation"));
21721       assertFalse(GrouperClientWs.mostRecentRequest,
21722           GrouperClientWs.mostRecentRequest.contains("sortString"));
21723       assertFalse(GrouperClientWs.mostRecentRequest,
21724           GrouperClientWs.mostRecentRequest.contains("ascending"));
21725       assertFalse(GrouperClientWs.mostRecentRequest,
21726           GrouperClientWs.mostRecentRequest.contains("pageNumber"));
21727       assertFalse(GrouperClientWs.mostRecentRequest,
21728           GrouperClientWs.mostRecentRequest.contains("pageSize"));
21729 
21730 
21731       // ############################
21732       //[--sortString=name|displayName|extension|displayExtension] [--ascending=T|F] [--pageNumber=2] [--pageSize=50]
21733       baos = new ByteArrayOutputStream();
21734 
21735       System.setOut(new PrintStream(baos));
21736 
21737       GrouperClient.main(GrouperClientUtils.splitTrim(
21738           "--operation=findAttributeDefNamesWs --scope=aStem --sortString=extension --ascending=F --pageNumber=2 --pageSize=2", " "));
21739       System.out.flush();
21740       output = new String(baos.toByteArray());
21741 
21742       systemOut.println(output);
21743 
21744       System.setOut(systemOut);
21745 
21746       outputLines = GrouperClientUtils.splitTrim(output, "\n");
21747 
21748       assertEquals(2, outputLines.length);
21749 
21750       //Index ${index}: name: ${wsAttributeDefName.name}, displayName: ${wsAttributeDefName.displayName}$newline$
21751       matcher = pattern.matcher(outputLines[0]);
21752 
21753       assertTrue(outputLines[0], matcher.matches());
21754 
21755       assertEquals(outputLines[0], "0", matcher.group(1));
21756       assertEquals(outputLines[0], "aStem1:newAttributeDefName2", matcher.group(2));
21757       assertEquals(outputLines[0], "aStem1:newAttributeDefName2", matcher.group(3));
21758 
21759       assertFalse(GrouperClientWs.mostRecentRequest,
21760           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
21761       assertFalse(GrouperClientWs.mostRecentRequest,
21762           GrouperClientWs.mostRecentRequest.contains("wsInheritanceSetRelation"));
21763       assertTrue(GrouperClientWs.mostRecentRequest,
21764           GrouperClientWs.mostRecentRequest.contains("sortString"));
21765       assertTrue(GrouperClientWs.mostRecentRequest,
21766           GrouperClientWs.mostRecentRequest.contains("ascending"));
21767       assertTrue(GrouperClientWs.mostRecentRequest,
21768           GrouperClientWs.mostRecentRequest.contains("pageNumber"));
21769       assertTrue(GrouperClientWs.mostRecentRequest,
21770           GrouperClientWs.mostRecentRequest.contains("pageSize"));
21771 
21772 
21773     } finally {
21774       System.setOut(systemOut);
21775     }
21776 
21777   }
21778 
21779   /**
21780    * @throws Exception
21781    */
21782   public void testAssignAttributeDefNameInheritanceWs() throws Exception {
21783 
21784     PrintStream systemOut = System.out;
21785 
21786     ByteArrayOutputStream baos = new ByteArrayOutputStream();
21787     System.setOut(new PrintStream(baos));
21788     String output = null;
21789     String[] outputLines = null;
21790     Pattern pattern = null;
21791     Matcher matcher = null;
21792     try {
21793 
21794       GrouperSession grouperSession = GrouperSession.startRootSession();
21795 
21796       AttributeDef attributeDef = new AttributeDefSave(grouperSession).assignName("aStem:newAttributeDef")
21797         .assignCreateParentStemsIfNotExist(true).assignAttributeDefType(AttributeDefType.perm).save();
21798 
21799       AttributeDefName attributeDefName = new AttributeDefNameSave(grouperSession, attributeDef).assignName("aStem:newAttributeDefName")
21800         .assignCreateParentStemsIfNotExist(true).save();
21801 
21802       AttributeDefName attributeDefName2 = new AttributeDefNameSave(grouperSession, attributeDef).assignName("aStem:newAttributeDefName2")
21803         .assignCreateParentStemsIfNotExist(true).save();
21804 
21805       AttributeDefName attributeDefName3 = new AttributeDefNameSave(grouperSession, attributeDef).assignName("aStem:newAttributeDefName3")
21806         .assignCreateParentStemsIfNotExist(true).save();
21807 
21808       GrouperClient.main(GrouperClientUtils.splitTrim(
21809           "--operation=assignAttributeDefNameInheritanceWs --attributeDefNameName=aStem:newAttributeDefName --relatedAttributeDefNameNames=aStem:newAttributeDefName2,aStem:newAttributeDefName3 --assign=T", " "));
21810       System.out.flush();
21811       output = new String(baos.toByteArray());
21812 
21813       systemOut.println(output);
21814 
21815       System.setOut(systemOut);
21816 
21817       outputLines = GrouperClientUtils.splitTrim(output, "\n");
21818 
21819       assertEquals(1, outputLines.length);
21820 
21821       //Success: ${resultMetadata.success}: code: ${resultMetadata.resultCode}, message: ${resultMetadata.resultMessage}$newline$
21822       pattern = Pattern.compile("^Success: (T|F): code: ([A-Z_]+), message: (.*+)$");
21823       matcher = pattern.matcher(outputLines[0]);
21824 
21825       assertTrue(outputLines[0], matcher.matches());
21826 
21827       assertEquals(outputLines[0], "T", matcher.group(1));
21828       assertEquals(outputLines[0], "SUCCESS", matcher.group(2));
21829       //Had 2 successful adds, 0 adds which already existed
21830       assertTrue(outputLines[0], matcher.group(3).contains("Had 2 successful adds"));
21831 
21832       // ############################
21833       //[--replaceAllExisting=T|F]
21834       baos = new ByteArrayOutputStream();
21835 
21836       System.setOut(new PrintStream(baos));
21837 
21838       GrouperClient.main(GrouperClientUtils.splitTrim(
21839           "--operation=assignAttributeDefNameInheritanceWs --attributeDefNameName=aStem:newAttributeDefName " +
21840           "--relatedAttributeDefNameNames=aStem:newAttributeDefName2,aStem:newAttributeDefName3 --assign=T --replaceAllExisting=T", " "));
21841       System.out.flush();
21842       output = new String(baos.toByteArray());
21843 
21844       systemOut.println(output);
21845 
21846       System.setOut(systemOut);
21847 
21848       outputLines = GrouperClientUtils.splitTrim(output, "\n");
21849 
21850       assertEquals(1, outputLines.length);
21851 
21852       matcher = pattern.matcher(outputLines[0]);
21853 
21854       assertTrue(outputLines[0], matcher.matches());
21855 
21856       assertEquals(outputLines[0], "T", matcher.group(1));
21857       assertEquals(outputLines[0], "SUCCESS", matcher.group(2));
21858       //Had 2 successful adds, 0 adds which already existed
21859       assertTrue(outputLines[0], matcher.group(3).contains("2 adds which already existed"));
21860 
21861       // ##########################
21862       // [--txType=NONE|READ_WRITE_NEW]
21863 
21864       baos = new ByteArrayOutputStream();
21865 
21866       System.setOut(new PrintStream(baos));
21867 
21868       GrouperClient.main(GrouperClientUtils.splitTrim(
21869           "--operation=assignAttributeDefNameInheritanceWs --attributeDefNameName=aStem:newAttributeDefName " +
21870           "--relatedAttributeDefNameNames=aStem:newAttributeDefName2,aStem:newAttributeDefName3 --assign=F --txType=READ_WRITE_NEW", " "));
21871       System.out.flush();
21872       output = new String(baos.toByteArray());
21873 
21874       systemOut.println(output);
21875 
21876       System.setOut(systemOut);
21877 
21878       outputLines = GrouperClientUtils.splitTrim(output, "\n");
21879 
21880       assertEquals(1, outputLines.length);
21881 
21882       matcher = pattern.matcher(outputLines[0]);
21883 
21884       assertTrue(outputLines[0], matcher.matches());
21885 
21886       assertEquals(outputLines[0], "T", matcher.group(1));
21887       assertEquals(outputLines[0], "SUCCESS", matcher.group(2));
21888       //Had 2 successful adds, 0 adds which already existed
21889       assertTrue(outputLines[0], matcher.group(3).contains("2 successful removes"));
21890 
21891       assertTrue(GrouperClientWs.mostRecentRequest,
21892           GrouperClientWs.mostRecentRequest.contains("txType") && GrouperClientWs.mostRecentRequest.contains("READ_WRITE_NEW"));
21893 
21894 
21895 
21896     } finally {
21897       System.setOut(systemOut);
21898     }
21899 
21900   }
21901 
21902   /**
21903    * @throws Exception
21904    */
21905   public void testGetAttributeAssignsGroupExtraFeatures() throws Exception {
21906 
21907     AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
21908     AttributeDefName attributeDefName2 = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignAssignName");
21909 
21910     final AttributeDef attributeDef = attributeDefName.getAttributeDef();
21911 
21912     attributeDef.setValueType(AttributeDefValueType.string);
21913     attributeDef.store();
21914 
21915     final AttributeDef attributeDef2 = attributeDefName2.getAttributeDef();
21916 
21917     attributeDef2.setAssignToGroup(false);
21918     attributeDef2.setAssignToGroupAssn(true);
21919     attributeDef2.setValueType(AttributeDefValueType.integer);
21920     attributeDef2.store();
21921 
21922     Group group = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
21923       .assignGroupNameToEdit("test:groupTestAttrAssign").assignName("test:groupTestAttrAssign").assignCreateParentStemsIfNotExist(true)
21924       .assignDescription("description").save();
21925 
21926     //test subject 0 can view and read
21927     group.grantPriv(SubjectTestHelper.SUBJ0, AccessPrivilege.VIEW);
21928     attributeDef.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ0, AttributeDefPrivilege.ATTR_READ, false);
21929 
21930     //test subject 0 can read the assignment on assignment
21931     attributeDef2.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ0, AttributeDefPrivilege.ATTR_READ, false);
21932 
21933     AttributeAssignResult attributeAssignResult = group.getAttributeDelegate().assignAttribute(attributeDefName);
21934     AttributeAssign attributeAssign = attributeAssignResult.getAttributeAssign();
21935     attributeAssign.getValueDelegate().assignValue("abc");
21936 
21937     AttributeAssignResult attributeAssignResult2 = attributeAssign.getAttributeDelegate().assignAttribute(attributeDefName2);
21938     AttributeAssign attributeAssign2 = attributeAssignResult2.getAttributeAssign();
21939     attributeAssign2.getValueDelegate().assignValue("123");
21940 
21941     PrintStream systemOut = System.out;
21942 
21943     ByteArrayOutputStream baos = new ByteArrayOutputStream();
21944     System.setOut(new PrintStream(baos));
21945 
21946     try {
21947 
21948       GrouperClient.main(GrouperClientUtils.splitTrim(
21949           "--operation=getAttributeAssignmentsWs --attributeAssignType=group " +
21950           "--attributeDefNames=test:testAttributeAssignDefNameDef " +
21951           "--attributeDefValueType=string --value=abc",
21952           " "));
21953       System.out.flush();
21954       String output = new String(baos.toByteArray());
21955 
21956       System.setOut(systemOut);
21957 
21958       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
21959 
21960       // match: Index: 0: attributeAssignType: group, owner: test:groupTestAttrAssign, attributeDefNameName test:testAttributeAssignDefName, action: assign, values: 15,5,5, enable: T, id: a9c83eeb78c04ae5befcea36272d318c
21961       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
21962       Pattern pattern = Pattern
21963           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
21964 
21965       assertEquals(1, GrouperUtil.length(outputLines));
21966       String outputLine = outputLines[0];
21967 
21968       Matcher matcher = pattern.matcher(outputLines[0]);
21969 
21970       assertTrue(outputLine, matcher.matches());
21971       assertEquals(outputLine, "0", matcher.group(1));
21972       assertEquals(outputLine, "group", matcher.group(2));
21973       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
21974       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
21975       assertEquals(outputLine, "assign", matcher.group(5));
21976       assertEquals(outputLine, "abc", matcher.group(6));
21977       assertEquals(outputLine, "T", matcher.group(7));
21978       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
21979 
21980       assertTrue(GrouperClientWs.mostRecentRequest,
21981           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
21982       assertTrue(GrouperClientWs.mostRecentRequest,
21983           !GrouperClientWs.mostRecentRequest.contains("actions"));
21984       assertTrue(GrouperClientWs.mostRecentRequest,
21985           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
21986       assertTrue(GrouperClientWs.mostRecentRequest,
21987           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
21988       assertTrue(GrouperClientWs.mostRecentRequest,
21989           !GrouperClientWs.mostRecentRequest.contains("enabled"));
21990       assertTrue(GrouperClientWs.mostRecentRequest,
21991           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
21992       assertTrue(GrouperClientWs.mostRecentRequest,
21993           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
21994       assertTrue(GrouperClientWs.mostRecentRequest,
21995           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
21996       assertTrue(GrouperClientWs.mostRecentRequest,
21997           !GrouperClientWs.mostRecentRequest.contains("params"));
21998       assertTrue(GrouperClientWs.mostRecentRequest,
21999           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
22000       assertTrue(GrouperClientWs.mostRecentRequest,
22001           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
22002       assertTrue(GrouperClientWs.mostRecentRequest,
22003           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
22004       assertTrue(GrouperClientWs.mostRecentRequest,
22005           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
22006       assertTrue(GrouperClientWs.mostRecentRequest,
22007           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
22008       assertTrue(GrouperClientWs.mostRecentRequest,
22009           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
22010       assertTrue(GrouperClientWs.mostRecentRequest,
22011           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
22012       assertTrue(GrouperClientWs.mostRecentRequest,
22013           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
22014       assertTrue(GrouperClientWs.mostRecentRequest,
22015           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
22016       assertTrue(GrouperClientWs.mostRecentRequest,
22017           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
22018       assertTrue(GrouperClientWs.mostRecentRequest,
22019           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
22020       assertTrue(GrouperClientWs.mostRecentRequest,
22021           GrouperClientWs.mostRecentRequest.contains("theValue"));
22022       assertTrue(GrouperClientWs.mostRecentRequest,
22023           GrouperClientWs.mostRecentRequest.contains("abc"));
22024       assertTrue(GrouperClientWs.mostRecentRequest,
22025           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
22026       assertTrue(GrouperClientWs.mostRecentRequest,
22027           !GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
22028       assertTrue(GrouperClientWs.mostRecentRequest,
22029           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
22030       assertTrue(GrouperClientWs.mostRecentRequest,
22031           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
22032       assertTrue(GrouperClientWs.mostRecentRequest,
22033           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
22034       assertTrue(GrouperClientWs.mostRecentRequest,
22035           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
22036       assertTrue(GrouperClientWs.mostRecentRequest,
22037           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
22038       assertTrue(GrouperClientWs.mostRecentRequest,
22039           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
22040 
22041       // ######################################################
22042       // Try wrong value
22043 
22044       baos = new ByteArrayOutputStream();
22045       System.setOut(new PrintStream(baos));
22046 
22047       GrouperClient.main(GrouperClientUtils.splitTrim(
22048           "--operation=getAttributeAssignmentsWs --attributeAssignType=group --attributeDefUuids=" + attributeDef.getId() +
22049           " --attributeDefNames=test:testAttributeAssignDefNameDef " +
22050           "--attributeDefValueType=string --value=123",
22051           " "));
22052 
22053 
22054       System.out.flush();
22055       output = new String(baos.toByteArray());
22056 
22057       System.setOut(systemOut);
22058 
22059       outputLines = GrouperClientUtils.splitTrim(output, "\n");
22060 
22061       assertEquals(0, GrouperUtil.length(outputLines));
22062 //      outputLine = outputLines[0];
22063 //
22064 //      matcher = pattern.matcher(outputLines[0]);
22065 
22066       assertTrue(GrouperClientWs.mostRecentRequest,
22067           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
22068       assertTrue(GrouperClientWs.mostRecentRequest,
22069           !GrouperClientWs.mostRecentRequest.contains("actions"));
22070       assertTrue(GrouperClientWs.mostRecentRequest,
22071           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
22072       assertTrue(GrouperClientWs.mostRecentRequest,
22073           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
22074       assertTrue(GrouperClientWs.mostRecentRequest,
22075           !GrouperClientWs.mostRecentRequest.contains("enabled"));
22076       assertTrue(GrouperClientWs.mostRecentRequest,
22077           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
22078       assertTrue(GrouperClientWs.mostRecentRequest,
22079           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
22080       assertTrue(GrouperClientWs.mostRecentRequest,
22081           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
22082       assertTrue(GrouperClientWs.mostRecentRequest,
22083           !GrouperClientWs.mostRecentRequest.contains("params"));
22084       assertTrue(GrouperClientWs.mostRecentRequest,
22085           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
22086       assertTrue(GrouperClientWs.mostRecentRequest,
22087           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
22088       assertTrue(GrouperClientWs.mostRecentRequest,
22089           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
22090       assertTrue(GrouperClientWs.mostRecentRequest,
22091           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
22092       assertTrue(GrouperClientWs.mostRecentRequest,
22093           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
22094       assertTrue(GrouperClientWs.mostRecentRequest,
22095           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
22096       assertTrue(GrouperClientWs.mostRecentRequest,
22097           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
22098       assertTrue(GrouperClientWs.mostRecentRequest,
22099           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
22100       assertTrue(GrouperClientWs.mostRecentRequest,
22101           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
22102       assertTrue(GrouperClientWs.mostRecentRequest,
22103           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
22104       assertTrue(GrouperClientWs.mostRecentRequest,
22105           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
22106       assertTrue(GrouperClientWs.mostRecentRequest,
22107           GrouperClientWs.mostRecentRequest.contains("theValue"));
22108       assertTrue(GrouperClientWs.mostRecentRequest,
22109           GrouperClientWs.mostRecentRequest.contains(">123<"));
22110       assertTrue(GrouperClientWs.mostRecentRequest,
22111           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
22112       assertTrue(GrouperClientWs.mostRecentRequest,
22113           !GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
22114       assertTrue(GrouperClientWs.mostRecentRequest,
22115           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
22116       assertTrue(GrouperClientWs.mostRecentRequest,
22117           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
22118       assertTrue(GrouperClientWs.mostRecentRequest,
22119           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
22120       assertTrue(GrouperClientWs.mostRecentRequest,
22121           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
22122       assertTrue(GrouperClientWs.mostRecentRequest,
22123           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
22124       assertTrue(GrouperClientWs.mostRecentRequest,
22125           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
22126 
22127 
22128       // ######################################################
22129       // Try wrong id
22130 
22131       baos = new ByteArrayOutputStream();
22132       System.setOut(new PrintStream(baos));
22133 
22134       try {
22135         GrouperClient.main(GrouperClientUtils.splitTrim(
22136             " --operation=getAttributeAssignmentsWs --attributeAssignType=group --attributeDefUuids=123" + attributeDef.getId() +
22137             " --attributeDefNames=test:testAttributeAssignDefNameDef " +
22138             "--attributeDefValueType=string --value=123",
22139             " "));
22140         fail("Shouldnt get here");
22141       } catch (GcWebServiceError gwse) {
22142         //ignore
22143       }
22144 
22145       // ######################################################
22146       // Try correct attributeDefType
22147 
22148       baos = new ByteArrayOutputStream();
22149       System.setOut(new PrintStream(baos));
22150 
22151       GrouperClient.main(GrouperClientUtils.splitTrim(
22152           "--operation=getAttributeAssignmentsWs --attributeAssignType=group --attributeDefUuids=" + attributeDef.getId() +
22153           " --attributeDefValueType=string --value=abc --attributeDefType=attr",
22154           " "));
22155 
22156 
22157       System.out.flush();
22158       output = new String(baos.toByteArray());
22159 
22160       System.setOut(systemOut);
22161 
22162       outputLines = GrouperClientUtils.splitTrim(output, "\n");
22163 
22164       // match: Index: 0: attributeAssignType: group, owner: test:groupTestAttrAssign, attributeDefNameName test:testAttributeAssignDefName, action: assign, values: 15,5,5, enable: T, id: a9c83eeb78c04ae5befcea36272d318c
22165       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
22166       pattern = Pattern
22167           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
22168 
22169       assertEquals(1, GrouperUtil.length(outputLines));
22170       outputLine = outputLines[0];
22171 
22172       matcher = pattern.matcher(outputLines[0]);
22173 
22174       assertTrue(outputLine, matcher.matches());
22175       assertEquals(outputLine, "0", matcher.group(1));
22176       assertEquals(outputLine, "group", matcher.group(2));
22177       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
22178       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
22179       assertEquals(outputLine, "assign", matcher.group(5));
22180       assertEquals(outputLine, "abc", matcher.group(6));
22181       assertEquals(outputLine, "T", matcher.group(7));
22182       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
22183 
22184       assertTrue(GrouperClientWs.mostRecentRequest,
22185           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
22186       assertTrue(GrouperClientWs.mostRecentRequest,
22187           !GrouperClientWs.mostRecentRequest.contains("actions"));
22188       assertTrue(GrouperClientWs.mostRecentRequest,
22189           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
22190       assertTrue(GrouperClientWs.mostRecentRequest,
22191           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
22192       assertTrue(GrouperClientWs.mostRecentRequest,
22193           !GrouperClientWs.mostRecentRequest.contains("enabled"));
22194       assertTrue(GrouperClientWs.mostRecentRequest,
22195           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
22196       assertTrue(GrouperClientWs.mostRecentRequest,
22197           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
22198       assertTrue(GrouperClientWs.mostRecentRequest,
22199           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
22200       assertTrue(GrouperClientWs.mostRecentRequest,
22201           !GrouperClientWs.mostRecentRequest.contains("params"));
22202       assertTrue(GrouperClientWs.mostRecentRequest,
22203           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
22204       assertTrue(GrouperClientWs.mostRecentRequest,
22205           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
22206       assertTrue(GrouperClientWs.mostRecentRequest,
22207           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
22208       assertTrue(GrouperClientWs.mostRecentRequest,
22209           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
22210       assertTrue(GrouperClientWs.mostRecentRequest,
22211           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
22212       assertTrue(GrouperClientWs.mostRecentRequest,
22213           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
22214       assertTrue(GrouperClientWs.mostRecentRequest,
22215           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
22216       assertTrue(GrouperClientWs.mostRecentRequest,
22217           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
22218       assertTrue(GrouperClientWs.mostRecentRequest,
22219           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
22220       assertTrue(GrouperClientWs.mostRecentRequest,
22221           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
22222       assertTrue(GrouperClientWs.mostRecentRequest,
22223           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
22224       assertTrue(GrouperClientWs.mostRecentRequest,
22225           GrouperClientWs.mostRecentRequest.contains("theValue"));
22226       assertTrue(GrouperClientWs.mostRecentRequest,
22227           GrouperClientWs.mostRecentRequest.contains("abc"));
22228       assertTrue(GrouperClientWs.mostRecentRequest,
22229           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
22230       assertTrue(GrouperClientWs.mostRecentRequest,
22231           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
22232       assertTrue(GrouperClientWs.mostRecentRequest,
22233           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
22234       assertTrue(GrouperClientWs.mostRecentRequest,
22235           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
22236       assertTrue(GrouperClientWs.mostRecentRequest,
22237           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
22238       assertTrue(GrouperClientWs.mostRecentRequest,
22239           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
22240       assertTrue(GrouperClientWs.mostRecentRequest,
22241           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
22242       assertTrue(GrouperClientWs.mostRecentRequest,
22243           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
22244 
22245       // ######################################################
22246       // Try wrong attributeDefType
22247 
22248       baos = new ByteArrayOutputStream();
22249       System.setOut(new PrintStream(baos));
22250 
22251       GrouperClient.main(GrouperClientUtils.splitTrim(
22252           "--operation=getAttributeAssignmentsWs --attributeAssignType=group --attributeDefUuids=" + attributeDef.getId() +
22253           " --attributeDefValueType=string --value=abc --attributeDefType=limit",
22254           " "));
22255 
22256       System.out.flush();
22257       output = new String(baos.toByteArray());
22258 
22259       System.setOut(systemOut);
22260 
22261       outputLines = GrouperClientUtils.splitTrim(output, "\n");
22262 
22263       // match: Index: 0: attributeAssignType: group, owner: test:groupTestAttrAssign, attributeDefNameName test:testAttributeAssignDefName, action: assign, values: 15,5,5, enable: T, id: a9c83eeb78c04ae5befcea36272d318c
22264       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
22265       pattern = Pattern
22266           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
22267 
22268       assertEquals(0, GrouperUtil.length(outputLines));
22269 
22270       assertTrue(GrouperClientWs.mostRecentRequest,
22271           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
22272       assertTrue(GrouperClientWs.mostRecentRequest,
22273           !GrouperClientWs.mostRecentRequest.contains("actions"));
22274       assertTrue(GrouperClientWs.mostRecentRequest,
22275           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
22276       assertTrue(GrouperClientWs.mostRecentRequest,
22277           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
22278       assertTrue(GrouperClientWs.mostRecentRequest,
22279           !GrouperClientWs.mostRecentRequest.contains("enabled"));
22280       assertTrue(GrouperClientWs.mostRecentRequest,
22281           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
22282       assertTrue(GrouperClientWs.mostRecentRequest,
22283           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
22284       assertTrue(GrouperClientWs.mostRecentRequest,
22285           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
22286       assertTrue(GrouperClientWs.mostRecentRequest,
22287           !GrouperClientWs.mostRecentRequest.contains("params"));
22288       assertTrue(GrouperClientWs.mostRecentRequest,
22289           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
22290       assertTrue(GrouperClientWs.mostRecentRequest,
22291           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
22292       assertTrue(GrouperClientWs.mostRecentRequest,
22293           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
22294       assertTrue(GrouperClientWs.mostRecentRequest,
22295           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
22296       assertTrue(GrouperClientWs.mostRecentRequest,
22297           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
22298       assertTrue(GrouperClientWs.mostRecentRequest,
22299           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
22300       assertTrue(GrouperClientWs.mostRecentRequest,
22301           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
22302       assertTrue(GrouperClientWs.mostRecentRequest,
22303           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
22304       assertTrue(GrouperClientWs.mostRecentRequest,
22305           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
22306       assertTrue(GrouperClientWs.mostRecentRequest,
22307           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
22308       assertTrue(GrouperClientWs.mostRecentRequest,
22309           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
22310       assertTrue(GrouperClientWs.mostRecentRequest,
22311           GrouperClientWs.mostRecentRequest.contains("theValue"));
22312       assertTrue(GrouperClientWs.mostRecentRequest,
22313           GrouperClientWs.mostRecentRequest.contains("abc"));
22314       assertTrue(GrouperClientWs.mostRecentRequest,
22315           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
22316       assertTrue(GrouperClientWs.mostRecentRequest,
22317           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
22318       assertTrue(GrouperClientWs.mostRecentRequest,
22319           GrouperClientWs.mostRecentRequest.contains("limit"));
22320       assertTrue(GrouperClientWs.mostRecentRequest,
22321           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
22322       assertTrue(GrouperClientWs.mostRecentRequest,
22323           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
22324       assertTrue(GrouperClientWs.mostRecentRequest,
22325           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
22326       assertTrue(GrouperClientWs.mostRecentRequest,
22327           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
22328       assertTrue(GrouperClientWs.mostRecentRequest,
22329           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
22330       assertTrue(GrouperClientWs.mostRecentRequest,
22331           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
22332 
22333       // ######################################################
22334       // Try group assignment on assignment by attributeDef
22335 
22336       baos = new ByteArrayOutputStream();
22337       System.setOut(new PrintStream(baos));
22338 
22339       GrouperClient.main(GrouperClientUtils.splitTrim(
22340           "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --attributeDefUuids=" + attributeDef2.getId(),
22341           " "));
22342 
22343       System.out.flush();
22344       output = new String(baos.toByteArray());
22345 
22346       System.setOut(systemOut);
22347 
22348       outputLines = GrouperClientUtils.splitTrim(output, "\n");
22349 
22350       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
22351       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
22352       pattern = Pattern
22353           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
22354 
22355       assertEquals(1, GrouperUtil.length(outputLines));
22356       outputLine = outputLines[0];
22357 
22358       matcher = pattern.matcher(outputLines[0]);
22359 
22360       assertTrue(outputLine, matcher.matches());
22361       assertEquals(outputLine, "0", matcher.group(1));
22362       assertEquals(outputLine, "group_asgn", matcher.group(2));
22363       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
22364       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
22365       assertEquals(outputLine, "assign", matcher.group(5));
22366       assertEquals(outputLine, "123", matcher.group(6));
22367       assertEquals(outputLine, "T", matcher.group(7));
22368       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
22369 
22370       assertTrue(GrouperClientWs.mostRecentRequest,
22371           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
22372       assertTrue(GrouperClientWs.mostRecentRequest,
22373           !GrouperClientWs.mostRecentRequest.contains("actions"));
22374       assertTrue(GrouperClientWs.mostRecentRequest,
22375           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
22376       assertTrue(GrouperClientWs.mostRecentRequest,
22377           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
22378       assertTrue(GrouperClientWs.mostRecentRequest,
22379           !GrouperClientWs.mostRecentRequest.contains("enabled"));
22380       assertTrue(GrouperClientWs.mostRecentRequest,
22381           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
22382       assertTrue(GrouperClientWs.mostRecentRequest,
22383           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
22384       assertTrue(GrouperClientWs.mostRecentRequest,
22385           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
22386       assertTrue(GrouperClientWs.mostRecentRequest,
22387           !GrouperClientWs.mostRecentRequest.contains("params"));
22388       assertTrue(GrouperClientWs.mostRecentRequest,
22389           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
22390       assertTrue(GrouperClientWs.mostRecentRequest,
22391           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
22392       assertTrue(GrouperClientWs.mostRecentRequest,
22393           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
22394       assertTrue(GrouperClientWs.mostRecentRequest,
22395           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
22396       assertTrue(GrouperClientWs.mostRecentRequest,
22397           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
22398       assertTrue(GrouperClientWs.mostRecentRequest,
22399           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
22400       assertTrue(GrouperClientWs.mostRecentRequest,
22401           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
22402       assertTrue(GrouperClientWs.mostRecentRequest,
22403           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
22404       assertTrue(GrouperClientWs.mostRecentRequest,
22405           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
22406       assertTrue(GrouperClientWs.mostRecentRequest,
22407           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
22408       assertFalse(GrouperClientWs.mostRecentRequest,
22409           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
22410       assertFalse(GrouperClientWs.mostRecentRequest,
22411           GrouperClientWs.mostRecentRequest.contains("theValue"));
22412       assertFalse(GrouperClientWs.mostRecentRequest,
22413           GrouperClientWs.mostRecentRequest.contains(">abc<"));
22414       assertTrue(GrouperClientWs.mostRecentRequest,
22415           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
22416       assertFalse(GrouperClientWs.mostRecentRequest,
22417           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
22418       assertTrue(GrouperClientWs.mostRecentRequest,
22419           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
22420       assertTrue(GrouperClientWs.mostRecentRequest,
22421           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
22422       assertTrue(GrouperClientWs.mostRecentRequest,
22423           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
22424       assertTrue(GrouperClientWs.mostRecentRequest,
22425           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
22426       assertTrue(GrouperClientWs.mostRecentRequest,
22427           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
22428       assertTrue(GrouperClientWs.mostRecentRequest,
22429           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
22430 
22431       // ######################################################
22432       // Try group assignment on assignment by attributeDef with wrong id
22433 
22434       baos = new ByteArrayOutputStream();
22435       System.setOut(new PrintStream(baos));
22436 
22437       try {
22438         GrouperClient.main(GrouperClientUtils.splitTrim(
22439             "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --attributeDefUuids=1" + attributeDef2.getId(),
22440             " "));
22441 
22442         System.out.flush();
22443         output = new String(baos.toByteArray());
22444 
22445         System.setOut(systemOut);
22446 
22447         outputLines = GrouperClientUtils.splitTrim(output, "\n");
22448 
22449         // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
22450         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
22451         pattern = Pattern
22452             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
22453 
22454         assertEquals(0, GrouperUtil.length(outputLines));
22455         fail("Why did it not fail?");
22456       } catch (Exception e) {
22457         //good
22458       }
22459       assertTrue(GrouperClientWs.mostRecentRequest,
22460           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
22461       assertTrue(GrouperClientWs.mostRecentRequest,
22462           !GrouperClientWs.mostRecentRequest.contains("actions"));
22463       assertTrue(GrouperClientWs.mostRecentRequest,
22464           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
22465       assertTrue(GrouperClientWs.mostRecentRequest,
22466           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
22467       assertTrue(GrouperClientWs.mostRecentRequest,
22468           !GrouperClientWs.mostRecentRequest.contains("enabled"));
22469       assertTrue(GrouperClientWs.mostRecentRequest,
22470           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
22471       assertTrue(GrouperClientWs.mostRecentRequest,
22472           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
22473       assertTrue(GrouperClientWs.mostRecentRequest,
22474           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
22475       assertTrue(GrouperClientWs.mostRecentRequest,
22476           !GrouperClientWs.mostRecentRequest.contains("params"));
22477       assertTrue(GrouperClientWs.mostRecentRequest,
22478           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
22479       assertTrue(GrouperClientWs.mostRecentRequest,
22480           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
22481       assertTrue(GrouperClientWs.mostRecentRequest,
22482           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
22483       assertTrue(GrouperClientWs.mostRecentRequest,
22484           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
22485       assertTrue(GrouperClientWs.mostRecentRequest,
22486           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
22487       assertTrue(GrouperClientWs.mostRecentRequest,
22488           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
22489       assertTrue(GrouperClientWs.mostRecentRequest,
22490           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
22491       assertTrue(GrouperClientWs.mostRecentRequest,
22492           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
22493       assertTrue(GrouperClientWs.mostRecentRequest,
22494           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
22495       assertTrue(GrouperClientWs.mostRecentRequest,
22496           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
22497       assertFalse(GrouperClientWs.mostRecentRequest,
22498           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
22499       assertFalse(GrouperClientWs.mostRecentRequest,
22500           GrouperClientWs.mostRecentRequest.contains("theValue"));
22501       assertFalse(GrouperClientWs.mostRecentRequest,
22502           GrouperClientWs.mostRecentRequest.contains("abc"));
22503       assertTrue(GrouperClientWs.mostRecentRequest,
22504           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
22505       assertFalse(GrouperClientWs.mostRecentRequest,
22506           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
22507       assertTrue(GrouperClientWs.mostRecentRequest,
22508           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
22509       assertTrue(GrouperClientWs.mostRecentRequest,
22510           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
22511       assertTrue(GrouperClientWs.mostRecentRequest,
22512           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
22513       assertTrue(GrouperClientWs.mostRecentRequest,
22514           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
22515       assertTrue(GrouperClientWs.mostRecentRequest,
22516           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
22517       assertTrue(GrouperClientWs.mostRecentRequest,
22518           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
22519 
22520 
22521       // ######################################################
22522       // Try group assignment on assignment by attributeDef and value
22523 
22524       baos = new ByteArrayOutputStream();
22525       System.setOut(new PrintStream(baos));
22526 
22527       GrouperClient.main(GrouperClientUtils.splitTrim(
22528           "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --attributeDefUuids=" + attributeDef2.getId()
22529           + " --attributeDefValueType=integer --value=123 ",
22530         " "));
22531 
22532       System.out.flush();
22533       output = new String(baos.toByteArray());
22534 
22535       System.setOut(systemOut);
22536 
22537       outputLines = GrouperClientUtils.splitTrim(output, "\n");
22538 
22539       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
22540       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
22541       pattern = Pattern
22542           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
22543 
22544       assertEquals(1, GrouperUtil.length(outputLines));
22545       outputLine = outputLines[0];
22546 
22547       matcher = pattern.matcher(outputLines[0]);
22548 
22549       assertTrue(outputLine, matcher.matches());
22550       assertEquals(outputLine, "0", matcher.group(1));
22551       assertEquals(outputLine, "group_asgn", matcher.group(2));
22552       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
22553       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
22554       assertEquals(outputLine, "assign", matcher.group(5));
22555       assertEquals(outputLine, "123", matcher.group(6));
22556       assertEquals(outputLine, "T", matcher.group(7));
22557       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
22558 
22559       assertTrue(GrouperClientWs.mostRecentRequest,
22560           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
22561       assertTrue(GrouperClientWs.mostRecentRequest,
22562           !GrouperClientWs.mostRecentRequest.contains("actions"));
22563       assertTrue(GrouperClientWs.mostRecentRequest,
22564           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
22565       assertTrue(GrouperClientWs.mostRecentRequest,
22566           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
22567       assertTrue(GrouperClientWs.mostRecentRequest,
22568           !GrouperClientWs.mostRecentRequest.contains("enabled"));
22569       assertTrue(GrouperClientWs.mostRecentRequest,
22570           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
22571       assertTrue(GrouperClientWs.mostRecentRequest,
22572           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
22573       assertTrue(GrouperClientWs.mostRecentRequest,
22574           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
22575       assertTrue(GrouperClientWs.mostRecentRequest,
22576           !GrouperClientWs.mostRecentRequest.contains("params"));
22577       assertTrue(GrouperClientWs.mostRecentRequest,
22578           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
22579       assertTrue(GrouperClientWs.mostRecentRequest,
22580           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
22581       assertTrue(GrouperClientWs.mostRecentRequest,
22582           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
22583       assertTrue(GrouperClientWs.mostRecentRequest,
22584           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
22585       assertTrue(GrouperClientWs.mostRecentRequest,
22586           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
22587       assertTrue(GrouperClientWs.mostRecentRequest,
22588           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
22589       assertTrue(GrouperClientWs.mostRecentRequest,
22590           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
22591       assertTrue(GrouperClientWs.mostRecentRequest,
22592           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
22593       assertTrue(GrouperClientWs.mostRecentRequest,
22594           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
22595       assertTrue(GrouperClientWs.mostRecentRequest,
22596           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
22597       assertTrue(GrouperClientWs.mostRecentRequest,
22598           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
22599       assertTrue(GrouperClientWs.mostRecentRequest,
22600           GrouperClientWs.mostRecentRequest.contains("theValue"));
22601       assertTrue(GrouperClientWs.mostRecentRequest,
22602           GrouperClientWs.mostRecentRequest.contains(">123<"));
22603       assertTrue(GrouperClientWs.mostRecentRequest,
22604           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
22605       assertFalse(GrouperClientWs.mostRecentRequest,
22606           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
22607       assertTrue(GrouperClientWs.mostRecentRequest,
22608           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
22609       assertTrue(GrouperClientWs.mostRecentRequest,
22610           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
22611       assertTrue(GrouperClientWs.mostRecentRequest,
22612           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
22613       assertTrue(GrouperClientWs.mostRecentRequest,
22614           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
22615       assertTrue(GrouperClientWs.mostRecentRequest,
22616           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
22617       assertTrue(GrouperClientWs.mostRecentRequest,
22618           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
22619 
22620 
22621       // ######################################################
22622       // Try group assignment on assignment by attributeDef and wrong value
22623 
22624       baos = new ByteArrayOutputStream();
22625       System.setOut(new PrintStream(baos));
22626 
22627       GrouperClient.main(GrouperClientUtils.splitTrim(
22628           "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --attributeDefUuids=" + attributeDef2.getId()
22629           + " --attributeDefValueType=integer --value=1234 ",
22630         " "));
22631 
22632       System.out.flush();
22633       output = new String(baos.toByteArray());
22634 
22635       System.setOut(systemOut);
22636 
22637       outputLines = GrouperClientUtils.splitTrim(output, "\n");
22638 
22639       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
22640       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
22641       pattern = Pattern
22642           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
22643 
22644       assertEquals(0, GrouperUtil.length(outputLines));
22645 
22646       assertTrue(GrouperClientWs.mostRecentRequest,
22647           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
22648       assertTrue(GrouperClientWs.mostRecentRequest,
22649           !GrouperClientWs.mostRecentRequest.contains("actions"));
22650       assertTrue(GrouperClientWs.mostRecentRequest,
22651           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
22652       assertTrue(GrouperClientWs.mostRecentRequest,
22653           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
22654       assertTrue(GrouperClientWs.mostRecentRequest,
22655           !GrouperClientWs.mostRecentRequest.contains("enabled"));
22656       assertTrue(GrouperClientWs.mostRecentRequest,
22657           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
22658       assertTrue(GrouperClientWs.mostRecentRequest,
22659           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
22660       assertTrue(GrouperClientWs.mostRecentRequest,
22661           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
22662       assertTrue(GrouperClientWs.mostRecentRequest,
22663           !GrouperClientWs.mostRecentRequest.contains("params"));
22664       assertTrue(GrouperClientWs.mostRecentRequest,
22665           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
22666       assertTrue(GrouperClientWs.mostRecentRequest,
22667           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
22668       assertTrue(GrouperClientWs.mostRecentRequest,
22669           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
22670       assertTrue(GrouperClientWs.mostRecentRequest,
22671           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
22672       assertTrue(GrouperClientWs.mostRecentRequest,
22673           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
22674       assertTrue(GrouperClientWs.mostRecentRequest,
22675           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
22676       assertTrue(GrouperClientWs.mostRecentRequest,
22677           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
22678       assertTrue(GrouperClientWs.mostRecentRequest,
22679           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
22680       assertTrue(GrouperClientWs.mostRecentRequest,
22681           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
22682       assertTrue(GrouperClientWs.mostRecentRequest,
22683           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
22684       assertTrue(GrouperClientWs.mostRecentRequest,
22685           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
22686       assertTrue(GrouperClientWs.mostRecentRequest,
22687           GrouperClientWs.mostRecentRequest.contains("theValue"));
22688       assertTrue(GrouperClientWs.mostRecentRequest,
22689           GrouperClientWs.mostRecentRequest.contains("1234"));
22690       assertTrue(GrouperClientWs.mostRecentRequest,
22691           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
22692       assertFalse(GrouperClientWs.mostRecentRequest,
22693           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
22694       assertTrue(GrouperClientWs.mostRecentRequest,
22695           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
22696       assertTrue(GrouperClientWs.mostRecentRequest,
22697           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
22698       assertTrue(GrouperClientWs.mostRecentRequest,
22699           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
22700       assertTrue(GrouperClientWs.mostRecentRequest,
22701           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
22702       assertTrue(GrouperClientWs.mostRecentRequest,
22703           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
22704       assertTrue(GrouperClientWs.mostRecentRequest,
22705           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
22706 
22707 
22708       // ######################################################
22709       // Try group assignment on assignment by attributeDef and value
22710 
22711       baos = new ByteArrayOutputStream();
22712       System.setOut(new PrintStream(baos));
22713 
22714       GrouperClient.main(GrouperClientUtils.splitTrim(
22715           "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --attributeDefUuids=" + attributeDef2.getId()
22716           + " --includeAssignmentsFromAssignments=T ",
22717         " "));
22718 
22719       System.out.flush();
22720       output = new String(baos.toByteArray());
22721 
22722       System.setOut(systemOut);
22723 
22724       outputLines = GrouperClientUtils.splitTrim(output, "\n");
22725 
22726       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
22727       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
22728       pattern = Pattern
22729           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
22730 
22731       assertEquals(2, GrouperUtil.length(outputLines));
22732       outputLine = outputLines[0];
22733 
22734       matcher = pattern.matcher(outputLine);
22735 
22736       assertTrue(outputLine, matcher.matches());
22737       assertEquals(outputLine, "0", matcher.group(1));
22738       assertEquals(outputLine, "group", matcher.group(2));
22739       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(3));
22740       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
22741       assertEquals(outputLine, "assign", matcher.group(5));
22742       assertEquals(outputLine, "abc", matcher.group(6));
22743       assertEquals(outputLine, "T", matcher.group(7));
22744       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
22745 
22746       outputLine = outputLines[1];
22747 
22748       matcher = pattern.matcher(outputLine);
22749 
22750       assertTrue(outputLine, matcher.matches());
22751       assertEquals(outputLine, "1", matcher.group(1));
22752       assertEquals(outputLine, "group_asgn", matcher.group(2));
22753       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
22754       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
22755       assertEquals(outputLine, "assign", matcher.group(5));
22756       assertEquals(outputLine, "123", matcher.group(6));
22757       assertEquals(outputLine, "T", matcher.group(7));
22758       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
22759 
22760       assertTrue(GrouperClientWs.mostRecentRequest,
22761           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
22762       assertTrue(GrouperClientWs.mostRecentRequest,
22763           !GrouperClientWs.mostRecentRequest.contains("actions"));
22764       assertTrue(GrouperClientWs.mostRecentRequest,
22765           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
22766       assertTrue(GrouperClientWs.mostRecentRequest,
22767           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
22768       assertTrue(GrouperClientWs.mostRecentRequest,
22769           !GrouperClientWs.mostRecentRequest.contains("enabled"));
22770       assertTrue(GrouperClientWs.mostRecentRequest,
22771           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
22772       assertTrue(GrouperClientWs.mostRecentRequest,
22773           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
22774       assertTrue(GrouperClientWs.mostRecentRequest,
22775           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
22776       assertTrue(GrouperClientWs.mostRecentRequest,
22777           !GrouperClientWs.mostRecentRequest.contains("params"));
22778       assertTrue(GrouperClientWs.mostRecentRequest,
22779           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
22780       assertTrue(GrouperClientWs.mostRecentRequest,
22781           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
22782       assertTrue(GrouperClientWs.mostRecentRequest,
22783           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
22784       assertTrue(GrouperClientWs.mostRecentRequest,
22785           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
22786       assertTrue(GrouperClientWs.mostRecentRequest,
22787           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
22788       assertTrue(GrouperClientWs.mostRecentRequest,
22789           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
22790       assertTrue(GrouperClientWs.mostRecentRequest,
22791           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
22792       assertTrue(GrouperClientWs.mostRecentRequest,
22793           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
22794       assertTrue(GrouperClientWs.mostRecentRequest,
22795           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
22796       assertTrue(GrouperClientWs.mostRecentRequest,
22797           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
22798       assertFalse(GrouperClientWs.mostRecentRequest,
22799           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
22800       assertFalse(GrouperClientWs.mostRecentRequest,
22801           GrouperClientWs.mostRecentRequest.contains("theValue"));
22802       assertFalse(GrouperClientWs.mostRecentRequest,
22803           GrouperClientWs.mostRecentRequest.contains(">123<"));
22804       assertTrue(GrouperClientWs.mostRecentRequest,
22805           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
22806       assertFalse(GrouperClientWs.mostRecentRequest,
22807           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
22808       assertTrue(GrouperClientWs.mostRecentRequest,
22809           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
22810       assertTrue(GrouperClientWs.mostRecentRequest,
22811           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
22812       assertTrue(GrouperClientWs.mostRecentRequest,
22813           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
22814       assertTrue(GrouperClientWs.mostRecentRequest,
22815           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
22816       assertTrue(GrouperClientWs.mostRecentRequest,
22817           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
22818       assertTrue(GrouperClientWs.mostRecentRequest,
22819           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
22820 
22821 
22822       // ######################################################
22823       // Try group assignment on assignment by owner attribute assign id with wrong id
22824 
22825       baos = new ByteArrayOutputStream();
22826       System.setOut(new PrintStream(baos));
22827 
22828       try {
22829         GrouperClient.main(GrouperClientUtils.splitTrim(
22830             "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --assignAssignOwnerAttributeAssignUuids=1" + attributeAssign.getId()
22831             ,
22832           " "));
22833 
22834         System.out.flush();
22835         output = new String(baos.toByteArray());
22836 
22837         System.setOut(systemOut);
22838 
22839         outputLines = GrouperClientUtils.splitTrim(output, "\n");
22840 
22841         // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
22842         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
22843         pattern = Pattern
22844             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
22845 
22846         assertEquals(0, GrouperUtil.length(outputLines));
22847         fail("Shouldnt get here");
22848       } catch (Exception e) {
22849         //good
22850       } finally {
22851         System.setOut(systemOut);
22852 
22853       }
22854 
22855       assertTrue(GrouperClientWs.mostRecentRequest,
22856           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
22857       assertTrue(GrouperClientWs.mostRecentRequest,
22858           !GrouperClientWs.mostRecentRequest.contains("actions"));
22859       assertTrue(GrouperClientWs.mostRecentRequest,
22860           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
22861       assertTrue(GrouperClientWs.mostRecentRequest,
22862           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
22863       assertTrue(GrouperClientWs.mostRecentRequest,
22864           !GrouperClientWs.mostRecentRequest.contains("enabled"));
22865       assertTrue(GrouperClientWs.mostRecentRequest,
22866           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
22867       assertTrue(GrouperClientWs.mostRecentRequest,
22868           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
22869       assertTrue(GrouperClientWs.mostRecentRequest,
22870           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
22871       assertTrue(GrouperClientWs.mostRecentRequest,
22872           !GrouperClientWs.mostRecentRequest.contains("params"));
22873       assertTrue(GrouperClientWs.mostRecentRequest,
22874           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
22875       assertTrue(GrouperClientWs.mostRecentRequest,
22876           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
22877       assertFalse(GrouperClientWs.mostRecentRequest,
22878           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
22879       assertTrue(GrouperClientWs.mostRecentRequest,
22880           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
22881       assertTrue(GrouperClientWs.mostRecentRequest,
22882           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
22883       assertTrue(GrouperClientWs.mostRecentRequest,
22884           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
22885       assertTrue(GrouperClientWs.mostRecentRequest,
22886           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
22887       assertTrue(GrouperClientWs.mostRecentRequest,
22888           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
22889       assertTrue(GrouperClientWs.mostRecentRequest,
22890           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
22891       assertTrue(GrouperClientWs.mostRecentRequest,
22892           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
22893       assertTrue(GrouperClientWs.mostRecentRequest,
22894           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
22895       assertFalse(GrouperClientWs.mostRecentRequest,
22896           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
22897       assertFalse(GrouperClientWs.mostRecentRequest,
22898           GrouperClientWs.mostRecentRequest.contains("theValue"));
22899       assertFalse(GrouperClientWs.mostRecentRequest,
22900           GrouperClientWs.mostRecentRequest.contains(">123<"));
22901       assertFalse(GrouperClientWs.mostRecentRequest,
22902           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
22903       assertFalse(GrouperClientWs.mostRecentRequest,
22904           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
22905       assertTrue(GrouperClientWs.mostRecentRequest,
22906           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
22907       assertTrue(GrouperClientWs.mostRecentRequest,
22908           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
22909       assertTrue(GrouperClientWs.mostRecentRequest,
22910           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
22911       assertTrue(GrouperClientWs.mostRecentRequest,
22912           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
22913       assertTrue(GrouperClientWs.mostRecentRequest,
22914           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
22915       assertTrue(GrouperClientWs.mostRecentRequest,
22916           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
22917 
22918       // ######################################################
22919       // Try group assignment on assignment by owner attribute assign id
22920 
22921       baos = new ByteArrayOutputStream();
22922       System.setOut(new PrintStream(baos));
22923 
22924       GrouperClient.main(GrouperClientUtils.splitTrim(
22925           "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --assignAssignOwnerAttributeAssignUuids=" + attributeAssign.getId()
22926           ,
22927         " "));
22928 
22929       System.out.flush();
22930       output = new String(baos.toByteArray());
22931 
22932       System.setOut(systemOut);
22933 
22934       outputLines = GrouperClientUtils.splitTrim(output, "\n");
22935 
22936       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
22937       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
22938       pattern = Pattern
22939           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
22940 
22941       assertEquals(1, GrouperUtil.length(outputLines));
22942 
22943       outputLine = outputLines[0];
22944 
22945       matcher = pattern.matcher(outputLine);
22946 
22947       assertTrue(outputLine, matcher.matches());
22948       assertEquals(outputLine, "0", matcher.group(1));
22949       assertEquals(outputLine, "group_asgn", matcher.group(2));
22950       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
22951       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
22952       assertEquals(outputLine, "assign", matcher.group(5));
22953       assertEquals(outputLine, "123", matcher.group(6));
22954       assertEquals(outputLine, "T", matcher.group(7));
22955       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
22956 
22957       assertTrue(GrouperClientWs.mostRecentRequest,
22958           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
22959       assertTrue(GrouperClientWs.mostRecentRequest,
22960           !GrouperClientWs.mostRecentRequest.contains("actions"));
22961       assertTrue(GrouperClientWs.mostRecentRequest,
22962           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
22963       assertTrue(GrouperClientWs.mostRecentRequest,
22964           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
22965       assertTrue(GrouperClientWs.mostRecentRequest,
22966           !GrouperClientWs.mostRecentRequest.contains("enabled"));
22967       assertTrue(GrouperClientWs.mostRecentRequest,
22968           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
22969       assertTrue(GrouperClientWs.mostRecentRequest,
22970           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
22971       assertTrue(GrouperClientWs.mostRecentRequest,
22972           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
22973       assertTrue(GrouperClientWs.mostRecentRequest,
22974           !GrouperClientWs.mostRecentRequest.contains("params"));
22975       assertTrue(GrouperClientWs.mostRecentRequest,
22976           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
22977       assertTrue(GrouperClientWs.mostRecentRequest,
22978           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
22979       assertFalse(GrouperClientWs.mostRecentRequest,
22980           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
22981       assertTrue(GrouperClientWs.mostRecentRequest,
22982           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
22983       assertTrue(GrouperClientWs.mostRecentRequest,
22984           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
22985       assertTrue(GrouperClientWs.mostRecentRequest,
22986           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
22987       assertTrue(GrouperClientWs.mostRecentRequest,
22988           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
22989       assertTrue(GrouperClientWs.mostRecentRequest,
22990           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
22991       assertTrue(GrouperClientWs.mostRecentRequest,
22992           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
22993       assertTrue(GrouperClientWs.mostRecentRequest,
22994           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
22995       assertTrue(GrouperClientWs.mostRecentRequest,
22996           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
22997       assertFalse(GrouperClientWs.mostRecentRequest,
22998           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
22999       assertFalse(GrouperClientWs.mostRecentRequest,
23000           GrouperClientWs.mostRecentRequest.contains("theValue"));
23001       assertFalse(GrouperClientWs.mostRecentRequest,
23002           GrouperClientWs.mostRecentRequest.contains(">123<"));
23003       assertFalse(GrouperClientWs.mostRecentRequest,
23004           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
23005       assertFalse(GrouperClientWs.mostRecentRequest,
23006           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
23007       assertTrue(GrouperClientWs.mostRecentRequest,
23008           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
23009       assertTrue(GrouperClientWs.mostRecentRequest,
23010           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
23011       assertTrue(GrouperClientWs.mostRecentRequest,
23012           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
23013       assertTrue(GrouperClientWs.mostRecentRequest,
23014           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
23015       assertTrue(GrouperClientWs.mostRecentRequest,
23016           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
23017       assertTrue(GrouperClientWs.mostRecentRequest,
23018           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
23019 
23020 
23021       // ######################################################
23022       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefLookups
23023 
23024       baos = new ByteArrayOutputStream();
23025       System.setOut(new PrintStream(baos));
23026 
23027       GrouperClient.main(GrouperClientUtils.splitTrim(
23028           "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --assignAssignOwnerNamesOfAttributeDefs=" + attributeDef.getName()
23029           ,
23030         " "));
23031 
23032       System.out.flush();
23033       output = new String(baos.toByteArray());
23034 
23035       System.setOut(systemOut);
23036 
23037       outputLines = GrouperClientUtils.splitTrim(output, "\n");
23038 
23039       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
23040       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
23041       pattern = Pattern
23042           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
23043 
23044       assertEquals(1, GrouperUtil.length(outputLines));
23045 
23046       outputLine = outputLines[0];
23047 
23048       matcher = pattern.matcher(outputLine);
23049 
23050       assertTrue(outputLine, matcher.matches());
23051       assertEquals(outputLine, "0", matcher.group(1));
23052       assertEquals(outputLine, "group_asgn", matcher.group(2));
23053       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
23054       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
23055       assertEquals(outputLine, "assign", matcher.group(5));
23056       assertEquals(outputLine, "123", matcher.group(6));
23057       assertEquals(outputLine, "T", matcher.group(7));
23058       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
23059 
23060       assertTrue(GrouperClientWs.mostRecentRequest,
23061           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
23062       assertTrue(GrouperClientWs.mostRecentRequest,
23063           !GrouperClientWs.mostRecentRequest.contains("actions"));
23064       assertTrue(GrouperClientWs.mostRecentRequest,
23065           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
23066       assertTrue(GrouperClientWs.mostRecentRequest,
23067           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
23068       assertTrue(GrouperClientWs.mostRecentRequest,
23069           !GrouperClientWs.mostRecentRequest.contains("enabled"));
23070       assertTrue(GrouperClientWs.mostRecentRequest,
23071           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
23072       assertTrue(GrouperClientWs.mostRecentRequest,
23073           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
23074       assertTrue(GrouperClientWs.mostRecentRequest,
23075           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
23076       assertTrue(GrouperClientWs.mostRecentRequest,
23077           !GrouperClientWs.mostRecentRequest.contains("params"));
23078       assertTrue(GrouperClientWs.mostRecentRequest,
23079           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
23080       assertTrue(GrouperClientWs.mostRecentRequest,
23081           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
23082       assertFalse(GrouperClientWs.mostRecentRequest,
23083           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
23084       assertFalse(GrouperClientWs.mostRecentRequest,
23085           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
23086       assertTrue(GrouperClientWs.mostRecentRequest,
23087           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
23088       assertTrue(GrouperClientWs.mostRecentRequest,
23089           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
23090       assertTrue(GrouperClientWs.mostRecentRequest,
23091           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
23092       assertTrue(GrouperClientWs.mostRecentRequest,
23093           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
23094       assertTrue(GrouperClientWs.mostRecentRequest,
23095           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
23096       assertTrue(GrouperClientWs.mostRecentRequest,
23097           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
23098       assertTrue(GrouperClientWs.mostRecentRequest,
23099           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
23100       assertFalse(GrouperClientWs.mostRecentRequest,
23101           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
23102       assertFalse(GrouperClientWs.mostRecentRequest,
23103           GrouperClientWs.mostRecentRequest.contains("theValue"));
23104       assertFalse(GrouperClientWs.mostRecentRequest,
23105           GrouperClientWs.mostRecentRequest.contains(">123<"));
23106       assertFalse(GrouperClientWs.mostRecentRequest,
23107           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
23108       assertFalse(GrouperClientWs.mostRecentRequest,
23109           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
23110       assertTrue(GrouperClientWs.mostRecentRequest,
23111           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
23112       assertTrue(GrouperClientWs.mostRecentRequest,
23113           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
23114       assertTrue(GrouperClientWs.mostRecentRequest,
23115           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
23116       assertTrue(GrouperClientWs.mostRecentRequest,
23117           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
23118       assertTrue(GrouperClientWs.mostRecentRequest,
23119           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
23120       assertTrue(GrouperClientWs.mostRecentRequest,
23121           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
23122 
23123 
23124 
23125       // ######################################################
23126       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefLookups with wrong name
23127 
23128       baos = new ByteArrayOutputStream();
23129       System.setOut(new PrintStream(baos));
23130 
23131       try {
23132         GrouperClient.main(GrouperClientUtils.splitTrim(
23133             "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --assignAssignOwnerNamesOfAttributeDefs=1" + attributeDef.getName()
23134             ,
23135           " "));
23136 
23137         System.out.flush();
23138         output = new String(baos.toByteArray());
23139 
23140         System.setOut(systemOut);
23141 
23142         outputLines = GrouperClientUtils.splitTrim(output, "\n");
23143 
23144         // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
23145         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
23146         pattern = Pattern
23147             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
23148 
23149         assertEquals(0, GrouperUtil.length(outputLines));
23150 
23151         fail("shouldnt get here");
23152       } catch (Exception e) {
23153         //good
23154       } finally {
23155         System.setOut(systemOut);
23156       }
23157 
23158       assertTrue(GrouperClientWs.mostRecentRequest,
23159           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
23160       assertTrue(GrouperClientWs.mostRecentRequest,
23161           !GrouperClientWs.mostRecentRequest.contains("actions"));
23162       assertTrue(GrouperClientWs.mostRecentRequest,
23163           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
23164       assertTrue(GrouperClientWs.mostRecentRequest,
23165           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
23166       assertTrue(GrouperClientWs.mostRecentRequest,
23167           !GrouperClientWs.mostRecentRequest.contains("enabled"));
23168       assertTrue(GrouperClientWs.mostRecentRequest,
23169           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
23170       assertTrue(GrouperClientWs.mostRecentRequest,
23171           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
23172       assertTrue(GrouperClientWs.mostRecentRequest,
23173           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
23174       assertTrue(GrouperClientWs.mostRecentRequest,
23175           !GrouperClientWs.mostRecentRequest.contains("params"));
23176       assertTrue(GrouperClientWs.mostRecentRequest,
23177           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
23178       assertTrue(GrouperClientWs.mostRecentRequest,
23179           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
23180       assertFalse(GrouperClientWs.mostRecentRequest,
23181           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
23182       assertFalse(GrouperClientWs.mostRecentRequest,
23183           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
23184       assertTrue(GrouperClientWs.mostRecentRequest,
23185           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
23186       assertTrue(GrouperClientWs.mostRecentRequest,
23187           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
23188       assertTrue(GrouperClientWs.mostRecentRequest,
23189           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
23190       assertTrue(GrouperClientWs.mostRecentRequest,
23191           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
23192       assertTrue(GrouperClientWs.mostRecentRequest,
23193           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
23194       assertTrue(GrouperClientWs.mostRecentRequest,
23195           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
23196       assertTrue(GrouperClientWs.mostRecentRequest,
23197           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
23198       assertFalse(GrouperClientWs.mostRecentRequest,
23199           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
23200       assertFalse(GrouperClientWs.mostRecentRequest,
23201           GrouperClientWs.mostRecentRequest.contains("theValue"));
23202       assertFalse(GrouperClientWs.mostRecentRequest,
23203           GrouperClientWs.mostRecentRequest.contains(">123<"));
23204       assertFalse(GrouperClientWs.mostRecentRequest,
23205           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
23206       assertFalse(GrouperClientWs.mostRecentRequest,
23207           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
23208       assertTrue(GrouperClientWs.mostRecentRequest,
23209           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
23210       assertTrue(GrouperClientWs.mostRecentRequest,
23211           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
23212       assertTrue(GrouperClientWs.mostRecentRequest,
23213           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
23214       assertTrue(GrouperClientWs.mostRecentRequest,
23215           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
23216       assertTrue(GrouperClientWs.mostRecentRequest,
23217           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
23218       assertTrue(GrouperClientWs.mostRecentRequest,
23219           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
23220 
23221 
23222       // ######################################################
23223       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefLookups
23224 
23225       baos = new ByteArrayOutputStream();
23226       System.setOut(new PrintStream(baos));
23227 
23228       GrouperClient.main(GrouperClientUtils.splitTrim(
23229           "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --assignAssignOwnerUuidsOfAttributeDefs=" + attributeDef.getId()
23230           ,
23231         " "));
23232 
23233       System.out.flush();
23234       output = new String(baos.toByteArray());
23235 
23236       System.setOut(systemOut);
23237 
23238       outputLines = GrouperClientUtils.splitTrim(output, "\n");
23239 
23240       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
23241       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
23242       pattern = Pattern
23243           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
23244 
23245       assertEquals(1, GrouperUtil.length(outputLines));
23246 
23247       outputLine = outputLines[0];
23248 
23249       matcher = pattern.matcher(outputLine);
23250 
23251       assertTrue(outputLine, matcher.matches());
23252       assertEquals(outputLine, "0", matcher.group(1));
23253       assertEquals(outputLine, "group_asgn", matcher.group(2));
23254       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
23255       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
23256       assertEquals(outputLine, "assign", matcher.group(5));
23257       assertEquals(outputLine, "123", matcher.group(6));
23258       assertEquals(outputLine, "T", matcher.group(7));
23259       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
23260 
23261       assertTrue(GrouperClientWs.mostRecentRequest,
23262           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
23263       assertTrue(GrouperClientWs.mostRecentRequest,
23264           !GrouperClientWs.mostRecentRequest.contains("actions"));
23265       assertTrue(GrouperClientWs.mostRecentRequest,
23266           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
23267       assertTrue(GrouperClientWs.mostRecentRequest,
23268           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
23269       assertTrue(GrouperClientWs.mostRecentRequest,
23270           !GrouperClientWs.mostRecentRequest.contains("enabled"));
23271       assertTrue(GrouperClientWs.mostRecentRequest,
23272           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
23273       assertTrue(GrouperClientWs.mostRecentRequest,
23274           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
23275       assertTrue(GrouperClientWs.mostRecentRequest,
23276           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
23277       assertTrue(GrouperClientWs.mostRecentRequest,
23278           !GrouperClientWs.mostRecentRequest.contains("params"));
23279       assertTrue(GrouperClientWs.mostRecentRequest,
23280           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
23281       assertTrue(GrouperClientWs.mostRecentRequest,
23282           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
23283       assertFalse(GrouperClientWs.mostRecentRequest,
23284           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
23285       assertTrue(GrouperClientWs.mostRecentRequest,
23286           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
23287       assertTrue(GrouperClientWs.mostRecentRequest,
23288           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
23289       assertTrue(GrouperClientWs.mostRecentRequest,
23290           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
23291       assertTrue(GrouperClientWs.mostRecentRequest,
23292           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
23293       assertTrue(GrouperClientWs.mostRecentRequest,
23294           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
23295       assertTrue(GrouperClientWs.mostRecentRequest,
23296           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
23297       assertTrue(GrouperClientWs.mostRecentRequest,
23298           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
23299       assertTrue(GrouperClientWs.mostRecentRequest,
23300           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
23301       assertFalse(GrouperClientWs.mostRecentRequest,
23302           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
23303       assertFalse(GrouperClientWs.mostRecentRequest,
23304           GrouperClientWs.mostRecentRequest.contains("theValue"));
23305       assertFalse(GrouperClientWs.mostRecentRequest,
23306           GrouperClientWs.mostRecentRequest.contains(">123<"));
23307       assertFalse(GrouperClientWs.mostRecentRequest,
23308           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
23309       assertFalse(GrouperClientWs.mostRecentRequest,
23310           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
23311       assertTrue(GrouperClientWs.mostRecentRequest,
23312           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
23313       assertTrue(GrouperClientWs.mostRecentRequest,
23314           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
23315       assertTrue(GrouperClientWs.mostRecentRequest,
23316           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
23317       assertTrue(GrouperClientWs.mostRecentRequest,
23318           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
23319       assertTrue(GrouperClientWs.mostRecentRequest,
23320           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
23321       assertTrue(GrouperClientWs.mostRecentRequest,
23322           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
23323 
23324 
23325       // ######################################################
23326       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefLookups
23327 
23328       baos = new ByteArrayOutputStream();
23329       System.setOut(new PrintStream(baos));
23330 
23331       GrouperClient.main(GrouperClientUtils.splitTrim(
23332           "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --assignAssignOwnerUuidsOfAttributeDefs=" + attributeDef.getId()
23333           ,
23334         " "));
23335 
23336       System.out.flush();
23337       output = new String(baos.toByteArray());
23338 
23339       System.setOut(systemOut);
23340 
23341       outputLines = GrouperClientUtils.splitTrim(output, "\n");
23342 
23343       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
23344       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
23345       pattern = Pattern
23346           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
23347 
23348       assertEquals(1, GrouperUtil.length(outputLines));
23349 
23350       outputLine = outputLines[0];
23351 
23352       matcher = pattern.matcher(outputLine);
23353 
23354       assertTrue(outputLine, matcher.matches());
23355       assertEquals(outputLine, "0", matcher.group(1));
23356       assertEquals(outputLine, "group_asgn", matcher.group(2));
23357       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
23358       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
23359       assertEquals(outputLine, "assign", matcher.group(5));
23360       assertEquals(outputLine, "123", matcher.group(6));
23361       assertEquals(outputLine, "T", matcher.group(7));
23362       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
23363 
23364       assertTrue(GrouperClientWs.mostRecentRequest,
23365           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
23366       assertTrue(GrouperClientWs.mostRecentRequest,
23367           !GrouperClientWs.mostRecentRequest.contains("actions"));
23368       assertTrue(GrouperClientWs.mostRecentRequest,
23369           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
23370       assertTrue(GrouperClientWs.mostRecentRequest,
23371           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
23372       assertTrue(GrouperClientWs.mostRecentRequest,
23373           !GrouperClientWs.mostRecentRequest.contains("enabled"));
23374       assertTrue(GrouperClientWs.mostRecentRequest,
23375           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
23376       assertTrue(GrouperClientWs.mostRecentRequest,
23377           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
23378       assertTrue(GrouperClientWs.mostRecentRequest,
23379           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
23380       assertTrue(GrouperClientWs.mostRecentRequest,
23381           !GrouperClientWs.mostRecentRequest.contains("params"));
23382       assertTrue(GrouperClientWs.mostRecentRequest,
23383           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
23384       assertTrue(GrouperClientWs.mostRecentRequest,
23385           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
23386       assertFalse(GrouperClientWs.mostRecentRequest,
23387           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
23388       assertTrue(GrouperClientWs.mostRecentRequest,
23389           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
23390       assertTrue(GrouperClientWs.mostRecentRequest,
23391           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
23392       assertTrue(GrouperClientWs.mostRecentRequest,
23393           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
23394       assertTrue(GrouperClientWs.mostRecentRequest,
23395           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
23396       assertTrue(GrouperClientWs.mostRecentRequest,
23397           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
23398       assertTrue(GrouperClientWs.mostRecentRequest,
23399           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
23400       assertTrue(GrouperClientWs.mostRecentRequest,
23401           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
23402       assertTrue(GrouperClientWs.mostRecentRequest,
23403           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
23404       assertFalse(GrouperClientWs.mostRecentRequest,
23405           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
23406       assertFalse(GrouperClientWs.mostRecentRequest,
23407           GrouperClientWs.mostRecentRequest.contains("theValue"));
23408       assertFalse(GrouperClientWs.mostRecentRequest,
23409           GrouperClientWs.mostRecentRequest.contains(">123<"));
23410       assertFalse(GrouperClientWs.mostRecentRequest,
23411           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
23412       assertFalse(GrouperClientWs.mostRecentRequest,
23413           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
23414       assertTrue(GrouperClientWs.mostRecentRequest,
23415           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
23416       assertTrue(GrouperClientWs.mostRecentRequest,
23417           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
23418       assertTrue(GrouperClientWs.mostRecentRequest,
23419           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
23420       assertTrue(GrouperClientWs.mostRecentRequest,
23421           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
23422       assertTrue(GrouperClientWs.mostRecentRequest,
23423           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
23424       assertTrue(GrouperClientWs.mostRecentRequest,
23425           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
23426 
23427 
23428 
23429       // ######################################################
23430       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefLookups
23431 
23432       baos = new ByteArrayOutputStream();
23433       System.setOut(new PrintStream(baos));
23434 
23435       try {
23436         GrouperClient.main(GrouperClientUtils.splitTrim(
23437             "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --assignAssignOwnerUuidsOfAttributeDefs=1" + attributeDef.getId()
23438             ,
23439           " "));
23440 
23441         System.out.flush();
23442         output = new String(baos.toByteArray());
23443 
23444         System.setOut(systemOut);
23445 
23446         outputLines = GrouperClientUtils.splitTrim(output, "\n");
23447 
23448         // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
23449         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
23450         pattern = Pattern
23451             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
23452 
23453         assertEquals(0, GrouperUtil.length(outputLines));
23454         fail("Shouldnt get here");
23455       } catch (Exception e) {
23456         //good
23457       } finally {
23458 
23459         System.setOut(systemOut);
23460 
23461       }
23462 
23463       assertTrue(GrouperClientWs.mostRecentRequest,
23464           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
23465       assertTrue(GrouperClientWs.mostRecentRequest,
23466           !GrouperClientWs.mostRecentRequest.contains("actions"));
23467       assertTrue(GrouperClientWs.mostRecentRequest,
23468           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
23469       assertTrue(GrouperClientWs.mostRecentRequest,
23470           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
23471       assertTrue(GrouperClientWs.mostRecentRequest,
23472           !GrouperClientWs.mostRecentRequest.contains("enabled"));
23473       assertTrue(GrouperClientWs.mostRecentRequest,
23474           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
23475       assertTrue(GrouperClientWs.mostRecentRequest,
23476           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
23477       assertTrue(GrouperClientWs.mostRecentRequest,
23478           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
23479       assertTrue(GrouperClientWs.mostRecentRequest,
23480           !GrouperClientWs.mostRecentRequest.contains("params"));
23481       assertTrue(GrouperClientWs.mostRecentRequest,
23482           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
23483       assertTrue(GrouperClientWs.mostRecentRequest,
23484           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
23485       assertFalse(GrouperClientWs.mostRecentRequest,
23486           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
23487       assertTrue(GrouperClientWs.mostRecentRequest,
23488           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
23489       assertTrue(GrouperClientWs.mostRecentRequest,
23490           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
23491       assertTrue(GrouperClientWs.mostRecentRequest,
23492           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
23493       assertTrue(GrouperClientWs.mostRecentRequest,
23494           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
23495       assertTrue(GrouperClientWs.mostRecentRequest,
23496           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
23497       assertTrue(GrouperClientWs.mostRecentRequest,
23498           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
23499       assertTrue(GrouperClientWs.mostRecentRequest,
23500           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
23501       assertTrue(GrouperClientWs.mostRecentRequest,
23502           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
23503       assertFalse(GrouperClientWs.mostRecentRequest,
23504           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
23505       assertFalse(GrouperClientWs.mostRecentRequest,
23506           GrouperClientWs.mostRecentRequest.contains("theValue"));
23507       assertFalse(GrouperClientWs.mostRecentRequest,
23508           GrouperClientWs.mostRecentRequest.contains(">123<"));
23509       assertFalse(GrouperClientWs.mostRecentRequest,
23510           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
23511       assertFalse(GrouperClientWs.mostRecentRequest,
23512           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
23513       assertTrue(GrouperClientWs.mostRecentRequest,
23514           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
23515       assertTrue(GrouperClientWs.mostRecentRequest,
23516           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
23517       assertTrue(GrouperClientWs.mostRecentRequest,
23518           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
23519       assertTrue(GrouperClientWs.mostRecentRequest,
23520           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
23521       assertTrue(GrouperClientWs.mostRecentRequest,
23522           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
23523       assertTrue(GrouperClientWs.mostRecentRequest,
23524           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
23525 
23526 
23527       // ######################################################
23528       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups
23529 
23530       baos = new ByteArrayOutputStream();
23531       System.setOut(new PrintStream(baos));
23532 
23533       GrouperClient.main(GrouperClientUtils.splitTrim(
23534           "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --assignAssignOwnerNamesOfAttributeDefNames=" + attributeDefName.getName()
23535           ,
23536         " "));
23537 
23538       System.out.flush();
23539       output = new String(baos.toByteArray());
23540 
23541       System.setOut(systemOut);
23542 
23543       outputLines = GrouperClientUtils.splitTrim(output, "\n");
23544 
23545       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
23546       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
23547       pattern = Pattern
23548           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
23549 
23550       assertEquals(1, GrouperUtil.length(outputLines));
23551 
23552       outputLine = outputLines[0];
23553 
23554       matcher = pattern.matcher(outputLine);
23555 
23556       assertTrue(outputLine, matcher.matches());
23557       assertEquals(outputLine, "0", matcher.group(1));
23558       assertEquals(outputLine, "group_asgn", matcher.group(2));
23559       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
23560       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
23561       assertEquals(outputLine, "assign", matcher.group(5));
23562       assertEquals(outputLine, "123", matcher.group(6));
23563       assertEquals(outputLine, "T", matcher.group(7));
23564       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
23565 
23566       assertTrue(GrouperClientWs.mostRecentRequest,
23567           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
23568       assertTrue(GrouperClientWs.mostRecentRequest,
23569           !GrouperClientWs.mostRecentRequest.contains("actions"));
23570       assertTrue(GrouperClientWs.mostRecentRequest,
23571           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
23572       assertTrue(GrouperClientWs.mostRecentRequest,
23573           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
23574       assertTrue(GrouperClientWs.mostRecentRequest,
23575           !GrouperClientWs.mostRecentRequest.contains("enabled"));
23576       assertTrue(GrouperClientWs.mostRecentRequest,
23577           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
23578       assertTrue(GrouperClientWs.mostRecentRequest,
23579           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
23580       assertTrue(GrouperClientWs.mostRecentRequest,
23581           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
23582       assertTrue(GrouperClientWs.mostRecentRequest,
23583           !GrouperClientWs.mostRecentRequest.contains("params"));
23584       assertTrue(GrouperClientWs.mostRecentRequest,
23585           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
23586       assertTrue(GrouperClientWs.mostRecentRequest,
23587           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
23588       assertFalse(GrouperClientWs.mostRecentRequest,
23589           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
23590       assertFalse(GrouperClientWs.mostRecentRequest,
23591           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
23592       assertTrue(GrouperClientWs.mostRecentRequest,
23593           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
23594       assertTrue(GrouperClientWs.mostRecentRequest,
23595           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
23596       assertTrue(GrouperClientWs.mostRecentRequest,
23597           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
23598       assertTrue(GrouperClientWs.mostRecentRequest,
23599           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
23600       assertTrue(GrouperClientWs.mostRecentRequest,
23601           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
23602       assertTrue(GrouperClientWs.mostRecentRequest,
23603           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
23604       assertTrue(GrouperClientWs.mostRecentRequest,
23605           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
23606       assertFalse(GrouperClientWs.mostRecentRequest,
23607           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
23608       assertFalse(GrouperClientWs.mostRecentRequest,
23609           GrouperClientWs.mostRecentRequest.contains("theValue"));
23610       assertFalse(GrouperClientWs.mostRecentRequest,
23611           GrouperClientWs.mostRecentRequest.contains(">123<"));
23612       assertFalse(GrouperClientWs.mostRecentRequest,
23613           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
23614       assertFalse(GrouperClientWs.mostRecentRequest,
23615           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
23616       assertTrue(GrouperClientWs.mostRecentRequest,
23617           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
23618       assertTrue(GrouperClientWs.mostRecentRequest,
23619           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
23620       assertTrue(GrouperClientWs.mostRecentRequest,
23621           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
23622       assertTrue(GrouperClientWs.mostRecentRequest,
23623           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
23624 
23625 
23626 
23627       // ######################################################
23628       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups
23629 
23630       baos = new ByteArrayOutputStream();
23631       System.setOut(new PrintStream(baos));
23632 
23633       try {
23634         GrouperClient.main(GrouperClientUtils.splitTrim(
23635             "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --assignAssignOwnerNamesOfAttributeDefNames=1" + attributeDefName.getName()
23636             ,
23637           " "));
23638 
23639         System.out.flush();
23640         output = new String(baos.toByteArray());
23641 
23642         System.setOut(systemOut);
23643 
23644         outputLines = GrouperClientUtils.splitTrim(output, "\n");
23645 
23646         // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
23647         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
23648         pattern = Pattern
23649             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
23650 
23651         assertEquals(0, GrouperUtil.length(outputLines));
23652         fail("Shouldnt get here");
23653 
23654       } catch (Exception e) {
23655         //ok
23656       } finally {
23657 
23658         System.setOut(systemOut);
23659 
23660       }
23661 
23662       assertTrue(GrouperClientWs.mostRecentRequest,
23663           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
23664       assertTrue(GrouperClientWs.mostRecentRequest,
23665           !GrouperClientWs.mostRecentRequest.contains("actions"));
23666       assertTrue(GrouperClientWs.mostRecentRequest,
23667           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
23668       assertTrue(GrouperClientWs.mostRecentRequest,
23669           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
23670       assertTrue(GrouperClientWs.mostRecentRequest,
23671           !GrouperClientWs.mostRecentRequest.contains("enabled"));
23672       assertTrue(GrouperClientWs.mostRecentRequest,
23673           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
23674       assertTrue(GrouperClientWs.mostRecentRequest,
23675           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
23676       assertTrue(GrouperClientWs.mostRecentRequest,
23677           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
23678       assertTrue(GrouperClientWs.mostRecentRequest,
23679           !GrouperClientWs.mostRecentRequest.contains("params"));
23680       assertTrue(GrouperClientWs.mostRecentRequest,
23681           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
23682       assertTrue(GrouperClientWs.mostRecentRequest,
23683           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
23684       assertFalse(GrouperClientWs.mostRecentRequest,
23685           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
23686       assertFalse(GrouperClientWs.mostRecentRequest,
23687           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
23688       assertTrue(GrouperClientWs.mostRecentRequest,
23689           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
23690       assertTrue(GrouperClientWs.mostRecentRequest,
23691           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
23692       assertTrue(GrouperClientWs.mostRecentRequest,
23693           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
23694       assertTrue(GrouperClientWs.mostRecentRequest,
23695           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
23696       assertTrue(GrouperClientWs.mostRecentRequest,
23697           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
23698       assertTrue(GrouperClientWs.mostRecentRequest,
23699           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
23700       assertTrue(GrouperClientWs.mostRecentRequest,
23701           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
23702       assertFalse(GrouperClientWs.mostRecentRequest,
23703           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
23704       assertFalse(GrouperClientWs.mostRecentRequest,
23705           GrouperClientWs.mostRecentRequest.contains("theValue"));
23706       assertFalse(GrouperClientWs.mostRecentRequest,
23707           GrouperClientWs.mostRecentRequest.contains(">123<"));
23708       assertFalse(GrouperClientWs.mostRecentRequest,
23709           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
23710       assertFalse(GrouperClientWs.mostRecentRequest,
23711           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
23712       assertTrue(GrouperClientWs.mostRecentRequest,
23713           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
23714       assertTrue(GrouperClientWs.mostRecentRequest,
23715           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
23716       assertTrue(GrouperClientWs.mostRecentRequest,
23717           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
23718       assertTrue(GrouperClientWs.mostRecentRequest,
23719           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
23720 
23721 
23722       // ######################################################
23723       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups
23724 
23725       baos = new ByteArrayOutputStream();
23726       System.setOut(new PrintStream(baos));
23727 
23728       GrouperClient.main(GrouperClientUtils.splitTrim(
23729           "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
23730           ,
23731         " "));
23732 
23733       System.out.flush();
23734       output = new String(baos.toByteArray());
23735 
23736       System.setOut(systemOut);
23737 
23738       outputLines = GrouperClientUtils.splitTrim(output, "\n");
23739 
23740       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
23741       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
23742       pattern = Pattern
23743           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
23744 
23745       assertEquals(1, GrouperUtil.length(outputLines));
23746 
23747       outputLine = outputLines[0];
23748 
23749       matcher = pattern.matcher(outputLine);
23750 
23751       assertTrue(outputLine, matcher.matches());
23752       assertEquals(outputLine, "0", matcher.group(1));
23753       assertEquals(outputLine, "group_asgn", matcher.group(2));
23754       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
23755       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
23756       assertEquals(outputLine, "assign", matcher.group(5));
23757       assertEquals(outputLine, "123", matcher.group(6));
23758       assertEquals(outputLine, "T", matcher.group(7));
23759       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
23760 
23761       assertTrue(GrouperClientWs.mostRecentRequest,
23762           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
23763       assertTrue(GrouperClientWs.mostRecentRequest,
23764           !GrouperClientWs.mostRecentRequest.contains("actions"));
23765       assertTrue(GrouperClientWs.mostRecentRequest,
23766           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
23767       assertTrue(GrouperClientWs.mostRecentRequest,
23768           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
23769       assertTrue(GrouperClientWs.mostRecentRequest,
23770           !GrouperClientWs.mostRecentRequest.contains("enabled"));
23771       assertTrue(GrouperClientWs.mostRecentRequest,
23772           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
23773       assertTrue(GrouperClientWs.mostRecentRequest,
23774           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
23775       assertTrue(GrouperClientWs.mostRecentRequest,
23776           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
23777       assertTrue(GrouperClientWs.mostRecentRequest,
23778           !GrouperClientWs.mostRecentRequest.contains("params"));
23779       assertTrue(GrouperClientWs.mostRecentRequest,
23780           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
23781       assertTrue(GrouperClientWs.mostRecentRequest,
23782           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
23783       assertFalse(GrouperClientWs.mostRecentRequest,
23784           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
23785       assertTrue(GrouperClientWs.mostRecentRequest,
23786           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
23787       assertTrue(GrouperClientWs.mostRecentRequest,
23788           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
23789       assertTrue(GrouperClientWs.mostRecentRequest,
23790           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
23791       assertTrue(GrouperClientWs.mostRecentRequest,
23792           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
23793       assertTrue(GrouperClientWs.mostRecentRequest,
23794           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
23795       assertTrue(GrouperClientWs.mostRecentRequest,
23796           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
23797       assertTrue(GrouperClientWs.mostRecentRequest,
23798           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
23799       assertTrue(GrouperClientWs.mostRecentRequest,
23800           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
23801       assertFalse(GrouperClientWs.mostRecentRequest,
23802           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
23803       assertFalse(GrouperClientWs.mostRecentRequest,
23804           GrouperClientWs.mostRecentRequest.contains("theValue"));
23805       assertFalse(GrouperClientWs.mostRecentRequest,
23806           GrouperClientWs.mostRecentRequest.contains(">123<"));
23807       assertFalse(GrouperClientWs.mostRecentRequest,
23808           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
23809       assertFalse(GrouperClientWs.mostRecentRequest,
23810           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
23811       assertTrue(GrouperClientWs.mostRecentRequest,
23812           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
23813       assertTrue(GrouperClientWs.mostRecentRequest,
23814           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
23815       assertTrue(GrouperClientWs.mostRecentRequest,
23816           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
23817       assertTrue(GrouperClientWs.mostRecentRequest,
23818           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
23819 
23820 
23821 
23822       // ######################################################
23823       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups wrong name
23824 
23825       baos = new ByteArrayOutputStream();
23826       System.setOut(new PrintStream(baos));
23827 
23828       try {
23829         GrouperClient.main(GrouperClientUtils.splitTrim(
23830             "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --assignAssignOwnerUuidsOfAttributeDefNames=1" + attributeDefName.getId()
23831             ,
23832           " "));
23833 
23834         System.out.flush();
23835         output = new String(baos.toByteArray());
23836 
23837         System.setOut(systemOut);
23838 
23839         outputLines = GrouperClientUtils.splitTrim(output, "\n");
23840 
23841         // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
23842         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
23843         pattern = Pattern
23844             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
23845 
23846         assertEquals(1, GrouperUtil.length(outputLines));
23847         fail("Shouldnt get here");
23848       } catch (Exception e) {
23849         //good
23850       } finally {
23851 
23852         System.setOut(systemOut);
23853 
23854       }
23855 
23856       assertTrue(GrouperClientWs.mostRecentRequest,
23857           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
23858       assertTrue(GrouperClientWs.mostRecentRequest,
23859           !GrouperClientWs.mostRecentRequest.contains("actions"));
23860       assertTrue(GrouperClientWs.mostRecentRequest,
23861           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
23862       assertTrue(GrouperClientWs.mostRecentRequest,
23863           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
23864       assertTrue(GrouperClientWs.mostRecentRequest,
23865           !GrouperClientWs.mostRecentRequest.contains("enabled"));
23866       assertTrue(GrouperClientWs.mostRecentRequest,
23867           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
23868       assertTrue(GrouperClientWs.mostRecentRequest,
23869           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
23870       assertTrue(GrouperClientWs.mostRecentRequest,
23871           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
23872       assertTrue(GrouperClientWs.mostRecentRequest,
23873           !GrouperClientWs.mostRecentRequest.contains("params"));
23874       assertTrue(GrouperClientWs.mostRecentRequest,
23875           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
23876       assertTrue(GrouperClientWs.mostRecentRequest,
23877           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
23878       assertFalse(GrouperClientWs.mostRecentRequest,
23879           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
23880       assertTrue(GrouperClientWs.mostRecentRequest,
23881           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
23882       assertTrue(GrouperClientWs.mostRecentRequest,
23883           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
23884       assertTrue(GrouperClientWs.mostRecentRequest,
23885           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
23886       assertTrue(GrouperClientWs.mostRecentRequest,
23887           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
23888       assertTrue(GrouperClientWs.mostRecentRequest,
23889           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
23890       assertTrue(GrouperClientWs.mostRecentRequest,
23891           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
23892       assertTrue(GrouperClientWs.mostRecentRequest,
23893           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
23894       assertTrue(GrouperClientWs.mostRecentRequest,
23895           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
23896       assertFalse(GrouperClientWs.mostRecentRequest,
23897           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
23898       assertFalse(GrouperClientWs.mostRecentRequest,
23899           GrouperClientWs.mostRecentRequest.contains("theValue"));
23900       assertFalse(GrouperClientWs.mostRecentRequest,
23901           GrouperClientWs.mostRecentRequest.contains(">123<"));
23902       assertFalse(GrouperClientWs.mostRecentRequest,
23903           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
23904       assertFalse(GrouperClientWs.mostRecentRequest,
23905           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
23906       assertTrue(GrouperClientWs.mostRecentRequest,
23907           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
23908       assertTrue(GrouperClientWs.mostRecentRequest,
23909           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
23910       assertTrue(GrouperClientWs.mostRecentRequest,
23911           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
23912       assertTrue(GrouperClientWs.mostRecentRequest,
23913           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
23914 
23915 
23916       // ######################################################
23917       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups
23918 
23919       baos = new ByteArrayOutputStream();
23920       System.setOut(new PrintStream(baos));
23921 
23922       GrouperClient.main(GrouperClientUtils.splitTrim(
23923           "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
23924           + " --assignAssignOwnerActions=assign",
23925         " "));
23926 
23927       System.out.flush();
23928       output = new String(baos.toByteArray());
23929 
23930       System.setOut(systemOut);
23931 
23932       outputLines = GrouperClientUtils.splitTrim(output, "\n");
23933 
23934       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
23935       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
23936       pattern = Pattern
23937           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
23938 
23939       assertEquals(1, GrouperUtil.length(outputLines));
23940 
23941       outputLine = outputLines[0];
23942 
23943       matcher = pattern.matcher(outputLine);
23944 
23945       assertTrue(outputLine, matcher.matches());
23946       assertEquals(outputLine, "0", matcher.group(1));
23947       assertEquals(outputLine, "group_asgn", matcher.group(2));
23948       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
23949       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
23950       assertEquals(outputLine, "assign", matcher.group(5));
23951       assertEquals(outputLine, "123", matcher.group(6));
23952       assertEquals(outputLine, "T", matcher.group(7));
23953       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
23954 
23955       assertTrue(GrouperClientWs.mostRecentRequest,
23956           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
23957       assertTrue(GrouperClientWs.mostRecentRequest,
23958           !GrouperClientWs.mostRecentRequest.contains("<actions>"));
23959       assertTrue(GrouperClientWs.mostRecentRequest,
23960           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
23961       assertTrue(GrouperClientWs.mostRecentRequest,
23962           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
23963       assertTrue(GrouperClientWs.mostRecentRequest,
23964           !GrouperClientWs.mostRecentRequest.contains("enabled"));
23965       assertTrue(GrouperClientWs.mostRecentRequest,
23966           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
23967       assertTrue(GrouperClientWs.mostRecentRequest,
23968           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
23969       assertTrue(GrouperClientWs.mostRecentRequest,
23970           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
23971       assertTrue(GrouperClientWs.mostRecentRequest,
23972           !GrouperClientWs.mostRecentRequest.contains("params"));
23973       assertTrue(GrouperClientWs.mostRecentRequest,
23974           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
23975       assertTrue(GrouperClientWs.mostRecentRequest,
23976           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
23977       assertFalse(GrouperClientWs.mostRecentRequest,
23978           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
23979       assertTrue(GrouperClientWs.mostRecentRequest,
23980           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
23981       assertTrue(GrouperClientWs.mostRecentRequest,
23982           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
23983       assertTrue(GrouperClientWs.mostRecentRequest,
23984           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
23985       assertTrue(GrouperClientWs.mostRecentRequest,
23986           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
23987       assertTrue(GrouperClientWs.mostRecentRequest,
23988           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
23989       assertTrue(GrouperClientWs.mostRecentRequest,
23990           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
23991       assertTrue(GrouperClientWs.mostRecentRequest,
23992           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
23993       assertTrue(GrouperClientWs.mostRecentRequest,
23994           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
23995       assertFalse(GrouperClientWs.mostRecentRequest,
23996           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
23997       assertFalse(GrouperClientWs.mostRecentRequest,
23998           GrouperClientWs.mostRecentRequest.contains("theValue"));
23999       assertFalse(GrouperClientWs.mostRecentRequest,
24000           GrouperClientWs.mostRecentRequest.contains(">123<"));
24001       assertFalse(GrouperClientWs.mostRecentRequest,
24002           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
24003       assertFalse(GrouperClientWs.mostRecentRequest,
24004           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
24005       assertTrue(GrouperClientWs.mostRecentRequest,
24006           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
24007       assertTrue(GrouperClientWs.mostRecentRequest,
24008           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
24009       assertTrue(GrouperClientWs.mostRecentRequest,
24010           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
24011       assertTrue(GrouperClientWs.mostRecentRequest,
24012           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
24013 
24014 
24015       // ######################################################
24016       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups wrong action
24017 
24018       baos = new ByteArrayOutputStream();
24019       System.setOut(new PrintStream(baos));
24020 
24021       GrouperClient.main(GrouperClientUtils.splitTrim(
24022           "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
24023           + " --assignAssignOwnerActions=assign2",
24024         " "));
24025 
24026       System.out.flush();
24027       output = new String(baos.toByteArray());
24028 
24029       System.setOut(systemOut);
24030 
24031       outputLines = GrouperClientUtils.splitTrim(output, "\n");
24032 
24033       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
24034       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
24035       pattern = Pattern
24036           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
24037 
24038       assertEquals(0, GrouperUtil.length(outputLines));
24039 
24040       assertTrue(GrouperClientWs.mostRecentRequest,
24041           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
24042       assertTrue(GrouperClientWs.mostRecentRequest,
24043           !GrouperClientWs.mostRecentRequest.contains("<actions>"));
24044       assertTrue(GrouperClientWs.mostRecentRequest,
24045           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
24046       assertTrue(GrouperClientWs.mostRecentRequest,
24047           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
24048       assertTrue(GrouperClientWs.mostRecentRequest,
24049           !GrouperClientWs.mostRecentRequest.contains("enabled"));
24050       assertTrue(GrouperClientWs.mostRecentRequest,
24051           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
24052       assertTrue(GrouperClientWs.mostRecentRequest,
24053           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
24054       assertTrue(GrouperClientWs.mostRecentRequest,
24055           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
24056       assertTrue(GrouperClientWs.mostRecentRequest,
24057           !GrouperClientWs.mostRecentRequest.contains("params"));
24058       assertTrue(GrouperClientWs.mostRecentRequest,
24059           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
24060       assertTrue(GrouperClientWs.mostRecentRequest,
24061           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
24062       assertFalse(GrouperClientWs.mostRecentRequest,
24063           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
24064       assertTrue(GrouperClientWs.mostRecentRequest,
24065           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
24066       assertTrue(GrouperClientWs.mostRecentRequest,
24067           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
24068       assertTrue(GrouperClientWs.mostRecentRequest,
24069           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
24070       assertTrue(GrouperClientWs.mostRecentRequest,
24071           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
24072       assertTrue(GrouperClientWs.mostRecentRequest,
24073           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
24074       assertTrue(GrouperClientWs.mostRecentRequest,
24075           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
24076       assertTrue(GrouperClientWs.mostRecentRequest,
24077           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
24078       assertTrue(GrouperClientWs.mostRecentRequest,
24079           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
24080       assertFalse(GrouperClientWs.mostRecentRequest,
24081           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
24082       assertFalse(GrouperClientWs.mostRecentRequest,
24083           GrouperClientWs.mostRecentRequest.contains("theValue"));
24084       assertFalse(GrouperClientWs.mostRecentRequest,
24085           GrouperClientWs.mostRecentRequest.contains(">123<"));
24086       assertFalse(GrouperClientWs.mostRecentRequest,
24087           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
24088       assertFalse(GrouperClientWs.mostRecentRequest,
24089           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
24090       assertTrue(GrouperClientWs.mostRecentRequest,
24091           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
24092       assertTrue(GrouperClientWs.mostRecentRequest,
24093           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
24094       assertTrue(GrouperClientWs.mostRecentRequest,
24095           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
24096       assertTrue(GrouperClientWs.mostRecentRequest,
24097           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
24098 
24099 
24100 
24101       // ######################################################
24102       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups
24103 
24104       baos = new ByteArrayOutputStream();
24105       System.setOut(new PrintStream(baos));
24106 
24107       GrouperClient.main(GrouperClientUtils.splitTrim(
24108           "--operation=getAttributeAssignmentsWs --attributeAssignType=group_asgn --ownerGroupNames=" + group.getName()
24109           ,
24110         " "));
24111 
24112       System.out.flush();
24113       output = new String(baos.toByteArray());
24114 
24115       System.setOut(systemOut);
24116 
24117       outputLines = GrouperClientUtils.splitTrim(output, "\n");
24118 
24119       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
24120       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
24121       pattern = Pattern
24122           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
24123 
24124       assertEquals(1, GrouperUtil.length(outputLines));
24125 
24126       outputLine = outputLines[0];
24127 
24128       matcher = pattern.matcher(outputLine);
24129 
24130       assertTrue(outputLine, matcher.matches());
24131       assertEquals(outputLine, "0", matcher.group(1));
24132       assertEquals(outputLine, "group_asgn", matcher.group(2));
24133       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
24134       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
24135       assertEquals(outputLine, "assign", matcher.group(5));
24136       assertEquals(outputLine, "123", matcher.group(6));
24137       assertEquals(outputLine, "T", matcher.group(7));
24138       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
24139 
24140       assertTrue(GrouperClientWs.mostRecentRequest,
24141           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
24142       assertTrue(GrouperClientWs.mostRecentRequest,
24143           !GrouperClientWs.mostRecentRequest.contains("<actions>"));
24144       assertTrue(GrouperClientWs.mostRecentRequest,
24145           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
24146       assertTrue(GrouperClientWs.mostRecentRequest,
24147           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
24148       assertTrue(GrouperClientWs.mostRecentRequest,
24149           !GrouperClientWs.mostRecentRequest.contains("enabled"));
24150       assertTrue(GrouperClientWs.mostRecentRequest,
24151           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
24152       assertTrue(GrouperClientWs.mostRecentRequest,
24153           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
24154       assertTrue(GrouperClientWs.mostRecentRequest,
24155           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
24156       assertTrue(GrouperClientWs.mostRecentRequest,
24157           !GrouperClientWs.mostRecentRequest.contains("params"));
24158       assertTrue(GrouperClientWs.mostRecentRequest,
24159           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
24160       assertTrue(GrouperClientWs.mostRecentRequest,
24161           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
24162       assertFalse(GrouperClientWs.mostRecentRequest,
24163           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
24164       assertFalse(GrouperClientWs.mostRecentRequest,
24165           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
24166       assertTrue(GrouperClientWs.mostRecentRequest,
24167           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
24168       assertTrue(GrouperClientWs.mostRecentRequest,
24169           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
24170       assertTrue(GrouperClientWs.mostRecentRequest,
24171           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
24172       assertTrue(GrouperClientWs.mostRecentRequest,
24173           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
24174       assertTrue(GrouperClientWs.mostRecentRequest,
24175           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
24176       assertTrue(GrouperClientWs.mostRecentRequest,
24177           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
24178       assertTrue(GrouperClientWs.mostRecentRequest,
24179           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
24180       assertFalse(GrouperClientWs.mostRecentRequest,
24181           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
24182       assertFalse(GrouperClientWs.mostRecentRequest,
24183           GrouperClientWs.mostRecentRequest.contains("theValue"));
24184       assertFalse(GrouperClientWs.mostRecentRequest,
24185           GrouperClientWs.mostRecentRequest.contains(">123<"));
24186       assertFalse(GrouperClientWs.mostRecentRequest,
24187           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
24188       assertFalse(GrouperClientWs.mostRecentRequest,
24189           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
24190       assertTrue(GrouperClientWs.mostRecentRequest,
24191           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
24192       assertTrue(GrouperClientWs.mostRecentRequest,
24193           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
24194       assertTrue(GrouperClientWs.mostRecentRequest,
24195           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
24196       assertTrue(GrouperClientWs.mostRecentRequest,
24197           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
24198 
24199 
24200     } finally {
24201       System.setOut(systemOut);
24202     }
24203 
24204   }
24205 
24206   /**
24207      * @throws Exception
24208      */
24209     public void testGetAttributeAssignsStemExtraFeatures() throws Exception {
24210 
24211       AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
24212       AttributeDefName attributeDefName2 = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignAssignName");
24213 
24214       final AttributeDef attributeDef = attributeDefName.getAttributeDef();
24215 
24216       attributeDef.setValueType(AttributeDefValueType.string);
24217       attributeDef.setAssignToStem(true);
24218       attributeDef.store();
24219 
24220       final AttributeDef attributeDef2 = attributeDefName2.getAttributeDef();
24221 
24222       attributeDef2.setAssignToGroup(false);
24223       attributeDef2.setAssignToStemAssn(true);
24224       attributeDef2.setValueType(AttributeDefValueType.integer);
24225       attributeDef2.store();
24226 
24227       Stem stem = new StemSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
24228         .assignName("test:stemTestAttrAssign").assignCreateParentStemsIfNotExist(true)
24229         .assignDescription("description").save();
24230 
24231       AttributeAssignResult attributeAssignResult = stem.getAttributeDelegate().assignAttribute(attributeDefName);
24232       AttributeAssign attributeAssign = attributeAssignResult.getAttributeAssign();
24233       attributeAssign.getValueDelegate().assignValue("abc");
24234 
24235       AttributeAssignResult attributeAssignResult2 = attributeAssign.getAttributeDelegate().assignAttribute(attributeDefName2);
24236       AttributeAssign attributeAssign2 = attributeAssignResult2.getAttributeAssign();
24237       attributeAssign2.getValueDelegate().assignValue("123");
24238 
24239       PrintStream systemOut = System.out;
24240 
24241       ByteArrayOutputStream baos = new ByteArrayOutputStream();
24242       System.setOut(new PrintStream(baos));
24243 
24244       try {
24245 
24246         GrouperClient.main(GrouperClientUtils.splitTrim(
24247             "--operation=getAttributeAssignmentsWs --attributeAssignType=stem " +
24248             "--attributeDefNames=test:testAttributeAssignDefNameDef " +
24249             "--attributeDefValueType=string --value=abc",
24250             " "));
24251         System.out.flush();
24252         String output = new String(baos.toByteArray());
24253 
24254         System.setOut(systemOut);
24255 
24256         String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
24257 
24258         // match: Index: 0: attributeAssignType: group, owner: test:stemTestAttrAssign, attributeDefNameName test:testAttributeAssignDefName, action: assign, values: 15,5,5, enable: T, id: a9c83eeb78c04ae5befcea36272d318c
24259         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
24260         Pattern pattern = Pattern
24261             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
24262 
24263         assertEquals(1, GrouperUtil.length(outputLines));
24264         String outputLine = outputLines[0];
24265 
24266         Matcher matcher = pattern.matcher(outputLines[0]);
24267 
24268         assertTrue(outputLine, matcher.matches());
24269         assertEquals(outputLine, "0", matcher.group(1));
24270         assertEquals(outputLine, "stem", matcher.group(2));
24271         assertEquals(outputLine, "test:stemTestAttrAssign", matcher.group(3));
24272         assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
24273         assertEquals(outputLine, "assign", matcher.group(5));
24274         assertEquals(outputLine, "abc", matcher.group(6));
24275         assertEquals(outputLine, "T", matcher.group(7));
24276         assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
24277 
24278         assertTrue(GrouperClientWs.mostRecentRequest,
24279             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
24280         assertTrue(GrouperClientWs.mostRecentRequest,
24281             !GrouperClientWs.mostRecentRequest.contains("actions"));
24282         assertTrue(GrouperClientWs.mostRecentRequest,
24283             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
24284         assertTrue(GrouperClientWs.mostRecentRequest,
24285             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
24286         assertTrue(GrouperClientWs.mostRecentRequest,
24287             !GrouperClientWs.mostRecentRequest.contains("enabled"));
24288         assertTrue(GrouperClientWs.mostRecentRequest,
24289             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
24290         assertTrue(GrouperClientWs.mostRecentRequest,
24291             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
24292         assertTrue(GrouperClientWs.mostRecentRequest,
24293             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
24294         assertTrue(GrouperClientWs.mostRecentRequest,
24295             !GrouperClientWs.mostRecentRequest.contains("params"));
24296         assertTrue(GrouperClientWs.mostRecentRequest,
24297             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
24298         assertTrue(GrouperClientWs.mostRecentRequest,
24299             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
24300         assertTrue(GrouperClientWs.mostRecentRequest,
24301             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
24302         assertTrue(GrouperClientWs.mostRecentRequest,
24303             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
24304         assertTrue(GrouperClientWs.mostRecentRequest,
24305             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
24306         assertTrue(GrouperClientWs.mostRecentRequest,
24307             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
24308         assertTrue(GrouperClientWs.mostRecentRequest,
24309             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
24310         assertTrue(GrouperClientWs.mostRecentRequest,
24311             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
24312         assertTrue(GrouperClientWs.mostRecentRequest,
24313             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
24314         assertTrue(GrouperClientWs.mostRecentRequest,
24315             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
24316         assertTrue(GrouperClientWs.mostRecentRequest,
24317             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
24318         assertTrue(GrouperClientWs.mostRecentRequest,
24319             GrouperClientWs.mostRecentRequest.contains("theValue"));
24320         assertTrue(GrouperClientWs.mostRecentRequest,
24321             GrouperClientWs.mostRecentRequest.contains("abc"));
24322         assertTrue(GrouperClientWs.mostRecentRequest,
24323             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
24324         assertTrue(GrouperClientWs.mostRecentRequest,
24325             !GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
24326         assertTrue(GrouperClientWs.mostRecentRequest,
24327             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
24328         assertTrue(GrouperClientWs.mostRecentRequest,
24329             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
24330         assertTrue(GrouperClientWs.mostRecentRequest,
24331             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
24332         assertTrue(GrouperClientWs.mostRecentRequest,
24333             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
24334         assertTrue(GrouperClientWs.mostRecentRequest,
24335             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
24336         assertTrue(GrouperClientWs.mostRecentRequest,
24337             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
24338 
24339         // ######################################################
24340         // Try wrong value
24341 
24342         baos = new ByteArrayOutputStream();
24343         System.setOut(new PrintStream(baos));
24344 
24345         GrouperClient.main(GrouperClientUtils.splitTrim(
24346             "--operation=getAttributeAssignmentsWs --attributeAssignType=stem --attributeDefUuids=" + attributeDef.getId() +
24347             " --attributeDefNames=test:testAttributeAssignDefNameDef " +
24348             "--attributeDefValueType=string --value=123",
24349             " "));
24350 
24351 
24352         System.out.flush();
24353         output = new String(baos.toByteArray());
24354 
24355         System.setOut(systemOut);
24356 
24357         outputLines = GrouperClientUtils.splitTrim(output, "\n");
24358 
24359         assertEquals(0, GrouperUtil.length(outputLines));
24360   //      outputLine = outputLines[0];
24361   //
24362   //      matcher = pattern.matcher(outputLines[0]);
24363 
24364         assertTrue(GrouperClientWs.mostRecentRequest,
24365             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
24366         assertTrue(GrouperClientWs.mostRecentRequest,
24367             !GrouperClientWs.mostRecentRequest.contains("actions"));
24368         assertTrue(GrouperClientWs.mostRecentRequest,
24369             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
24370         assertTrue(GrouperClientWs.mostRecentRequest,
24371             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
24372         assertTrue(GrouperClientWs.mostRecentRequest,
24373             !GrouperClientWs.mostRecentRequest.contains("enabled"));
24374         assertTrue(GrouperClientWs.mostRecentRequest,
24375             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
24376         assertTrue(GrouperClientWs.mostRecentRequest,
24377             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
24378         assertTrue(GrouperClientWs.mostRecentRequest,
24379             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
24380         assertTrue(GrouperClientWs.mostRecentRequest,
24381             !GrouperClientWs.mostRecentRequest.contains("params"));
24382         assertTrue(GrouperClientWs.mostRecentRequest,
24383             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
24384         assertTrue(GrouperClientWs.mostRecentRequest,
24385             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
24386         assertTrue(GrouperClientWs.mostRecentRequest,
24387             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
24388         assertTrue(GrouperClientWs.mostRecentRequest,
24389             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
24390         assertTrue(GrouperClientWs.mostRecentRequest,
24391             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
24392         assertTrue(GrouperClientWs.mostRecentRequest,
24393             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
24394         assertTrue(GrouperClientWs.mostRecentRequest,
24395             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
24396         assertTrue(GrouperClientWs.mostRecentRequest,
24397             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
24398         assertTrue(GrouperClientWs.mostRecentRequest,
24399             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
24400         assertTrue(GrouperClientWs.mostRecentRequest,
24401             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
24402         assertTrue(GrouperClientWs.mostRecentRequest,
24403             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
24404         assertTrue(GrouperClientWs.mostRecentRequest,
24405             GrouperClientWs.mostRecentRequest.contains("theValue"));
24406         assertTrue(GrouperClientWs.mostRecentRequest,
24407             GrouperClientWs.mostRecentRequest.contains(">123<"));
24408         assertTrue(GrouperClientWs.mostRecentRequest,
24409             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
24410         assertTrue(GrouperClientWs.mostRecentRequest,
24411             !GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
24412         assertTrue(GrouperClientWs.mostRecentRequest,
24413             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
24414         assertTrue(GrouperClientWs.mostRecentRequest,
24415             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
24416         assertTrue(GrouperClientWs.mostRecentRequest,
24417             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
24418         assertTrue(GrouperClientWs.mostRecentRequest,
24419             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
24420         assertTrue(GrouperClientWs.mostRecentRequest,
24421             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
24422         assertTrue(GrouperClientWs.mostRecentRequest,
24423             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
24424 
24425 
24426         // ######################################################
24427         // Try wrong id
24428 
24429         baos = new ByteArrayOutputStream();
24430         System.setOut(new PrintStream(baos));
24431 
24432         try {
24433           GrouperClient.main(GrouperClientUtils.splitTrim(
24434               " --operation=getAttributeAssignmentsWs --attributeAssignType=stem --attributeDefUuids=123" + attributeDef.getId() +
24435               " --attributeDefNames=test:testAttributeAssignDefNameDef " +
24436               "--attributeDefValueType=string --value=123",
24437               " "));
24438           fail("Shouldnt get here");
24439         } catch (GcWebServiceError gwse) {
24440           //ignore
24441         }
24442 
24443         // ######################################################
24444         // Try correct attributeDefType
24445 
24446         baos = new ByteArrayOutputStream();
24447         System.setOut(new PrintStream(baos));
24448 
24449         GrouperClient.main(GrouperClientUtils.splitTrim(
24450             "--operation=getAttributeAssignmentsWs --attributeAssignType=stem --attributeDefUuids=" + attributeDef.getId() +
24451             " --attributeDefValueType=string --value=abc --attributeDefType=attr",
24452             " "));
24453 
24454 
24455         System.out.flush();
24456         output = new String(baos.toByteArray());
24457 
24458         System.setOut(systemOut);
24459 
24460         outputLines = GrouperClientUtils.splitTrim(output, "\n");
24461 
24462         // match: Index: 0: attributeAssignType: group, owner: test:stemTestAttrAssign, attributeDefNameName test:testAttributeAssignDefName, action: assign, values: 15,5,5, enable: T, id: a9c83eeb78c04ae5befcea36272d318c
24463         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
24464         pattern = Pattern
24465             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
24466 
24467         assertEquals(1, GrouperUtil.length(outputLines));
24468         outputLine = outputLines[0];
24469 
24470         matcher = pattern.matcher(outputLines[0]);
24471 
24472         assertTrue(outputLine, matcher.matches());
24473         assertEquals(outputLine, "0", matcher.group(1));
24474         assertEquals(outputLine, "stem", matcher.group(2));
24475         assertEquals(outputLine, "test:stemTestAttrAssign", matcher.group(3));
24476         assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
24477         assertEquals(outputLine, "assign", matcher.group(5));
24478         assertEquals(outputLine, "abc", matcher.group(6));
24479         assertEquals(outputLine, "T", matcher.group(7));
24480         assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
24481 
24482         assertTrue(GrouperClientWs.mostRecentRequest,
24483             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
24484         assertTrue(GrouperClientWs.mostRecentRequest,
24485             !GrouperClientWs.mostRecentRequest.contains("actions"));
24486         assertTrue(GrouperClientWs.mostRecentRequest,
24487             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
24488         assertTrue(GrouperClientWs.mostRecentRequest,
24489             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
24490         assertTrue(GrouperClientWs.mostRecentRequest,
24491             !GrouperClientWs.mostRecentRequest.contains("enabled"));
24492         assertTrue(GrouperClientWs.mostRecentRequest,
24493             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
24494         assertTrue(GrouperClientWs.mostRecentRequest,
24495             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
24496         assertTrue(GrouperClientWs.mostRecentRequest,
24497             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
24498         assertTrue(GrouperClientWs.mostRecentRequest,
24499             !GrouperClientWs.mostRecentRequest.contains("params"));
24500         assertTrue(GrouperClientWs.mostRecentRequest,
24501             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
24502         assertTrue(GrouperClientWs.mostRecentRequest,
24503             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
24504         assertTrue(GrouperClientWs.mostRecentRequest,
24505             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
24506         assertTrue(GrouperClientWs.mostRecentRequest,
24507             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
24508         assertTrue(GrouperClientWs.mostRecentRequest,
24509             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
24510         assertTrue(GrouperClientWs.mostRecentRequest,
24511             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
24512         assertTrue(GrouperClientWs.mostRecentRequest,
24513             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
24514         assertTrue(GrouperClientWs.mostRecentRequest,
24515             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
24516         assertTrue(GrouperClientWs.mostRecentRequest,
24517             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
24518         assertTrue(GrouperClientWs.mostRecentRequest,
24519             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
24520         assertTrue(GrouperClientWs.mostRecentRequest,
24521             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
24522         assertTrue(GrouperClientWs.mostRecentRequest,
24523             GrouperClientWs.mostRecentRequest.contains("theValue"));
24524         assertTrue(GrouperClientWs.mostRecentRequest,
24525             GrouperClientWs.mostRecentRequest.contains("abc"));
24526         assertTrue(GrouperClientWs.mostRecentRequest,
24527             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
24528         assertTrue(GrouperClientWs.mostRecentRequest,
24529             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
24530         assertTrue(GrouperClientWs.mostRecentRequest,
24531             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
24532         assertTrue(GrouperClientWs.mostRecentRequest,
24533             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
24534         assertTrue(GrouperClientWs.mostRecentRequest,
24535             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
24536         assertTrue(GrouperClientWs.mostRecentRequest,
24537             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
24538         assertTrue(GrouperClientWs.mostRecentRequest,
24539             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
24540         assertTrue(GrouperClientWs.mostRecentRequest,
24541             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
24542 
24543         // ######################################################
24544         // Try wrong attributeDefType
24545 
24546         baos = new ByteArrayOutputStream();
24547         System.setOut(new PrintStream(baos));
24548 
24549         GrouperClient.main(GrouperClientUtils.splitTrim(
24550             "--operation=getAttributeAssignmentsWs --attributeAssignType=stem --attributeDefUuids=" + attributeDef.getId() +
24551             " --attributeDefValueType=string --value=abc --attributeDefType=limit",
24552             " "));
24553 
24554         System.out.flush();
24555         output = new String(baos.toByteArray());
24556 
24557         System.setOut(systemOut);
24558 
24559         outputLines = GrouperClientUtils.splitTrim(output, "\n");
24560 
24561         // match: Index: 0: attributeAssignType: group, owner: test:stemTestAttrAssign, attributeDefNameName test:testAttributeAssignDefName, action: assign, values: 15,5,5, enable: T, id: a9c83eeb78c04ae5befcea36272d318c
24562         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
24563         pattern = Pattern
24564             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
24565 
24566         assertEquals(0, GrouperUtil.length(outputLines));
24567 
24568         assertTrue(GrouperClientWs.mostRecentRequest,
24569             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
24570         assertTrue(GrouperClientWs.mostRecentRequest,
24571             !GrouperClientWs.mostRecentRequest.contains("actions"));
24572         assertTrue(GrouperClientWs.mostRecentRequest,
24573             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
24574         assertTrue(GrouperClientWs.mostRecentRequest,
24575             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
24576         assertTrue(GrouperClientWs.mostRecentRequest,
24577             !GrouperClientWs.mostRecentRequest.contains("enabled"));
24578         assertTrue(GrouperClientWs.mostRecentRequest,
24579             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
24580         assertTrue(GrouperClientWs.mostRecentRequest,
24581             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
24582         assertTrue(GrouperClientWs.mostRecentRequest,
24583             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
24584         assertTrue(GrouperClientWs.mostRecentRequest,
24585             !GrouperClientWs.mostRecentRequest.contains("params"));
24586         assertTrue(GrouperClientWs.mostRecentRequest,
24587             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
24588         assertTrue(GrouperClientWs.mostRecentRequest,
24589             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
24590         assertTrue(GrouperClientWs.mostRecentRequest,
24591             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
24592         assertTrue(GrouperClientWs.mostRecentRequest,
24593             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
24594         assertTrue(GrouperClientWs.mostRecentRequest,
24595             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
24596         assertTrue(GrouperClientWs.mostRecentRequest,
24597             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
24598         assertTrue(GrouperClientWs.mostRecentRequest,
24599             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
24600         assertTrue(GrouperClientWs.mostRecentRequest,
24601             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
24602         assertTrue(GrouperClientWs.mostRecentRequest,
24603             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
24604         assertTrue(GrouperClientWs.mostRecentRequest,
24605             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
24606         assertTrue(GrouperClientWs.mostRecentRequest,
24607             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
24608         assertTrue(GrouperClientWs.mostRecentRequest,
24609             GrouperClientWs.mostRecentRequest.contains("theValue"));
24610         assertTrue(GrouperClientWs.mostRecentRequest,
24611             GrouperClientWs.mostRecentRequest.contains("abc"));
24612         assertTrue(GrouperClientWs.mostRecentRequest,
24613             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
24614         assertTrue(GrouperClientWs.mostRecentRequest,
24615             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
24616         assertTrue(GrouperClientWs.mostRecentRequest,
24617             GrouperClientWs.mostRecentRequest.contains("limit"));
24618         assertTrue(GrouperClientWs.mostRecentRequest,
24619             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
24620         assertTrue(GrouperClientWs.mostRecentRequest,
24621             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
24622         assertTrue(GrouperClientWs.mostRecentRequest,
24623             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
24624         assertTrue(GrouperClientWs.mostRecentRequest,
24625             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
24626         assertTrue(GrouperClientWs.mostRecentRequest,
24627             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
24628         assertTrue(GrouperClientWs.mostRecentRequest,
24629             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
24630 
24631         // ######################################################
24632         // Try group assignment on assignment by attributeDef
24633 
24634         baos = new ByteArrayOutputStream();
24635         System.setOut(new PrintStream(baos));
24636 
24637         GrouperClient.main(GrouperClientUtils.splitTrim(
24638             "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --attributeDefUuids=" + attributeDef2.getId(),
24639             " "));
24640 
24641         System.out.flush();
24642         output = new String(baos.toByteArray());
24643 
24644         System.setOut(systemOut);
24645 
24646         outputLines = GrouperClientUtils.splitTrim(output, "\n");
24647 
24648         // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
24649         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
24650         pattern = Pattern
24651             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
24652 
24653         assertEquals(1, GrouperUtil.length(outputLines));
24654         outputLine = outputLines[0];
24655 
24656         matcher = pattern.matcher(outputLines[0]);
24657 
24658         assertTrue(outputLine, matcher.matches());
24659         assertEquals(outputLine, "0", matcher.group(1));
24660         assertEquals(outputLine, "stem_asgn", matcher.group(2));
24661         assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
24662         assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
24663         assertEquals(outputLine, "assign", matcher.group(5));
24664         assertEquals(outputLine, "123", matcher.group(6));
24665         assertEquals(outputLine, "T", matcher.group(7));
24666         assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
24667 
24668         assertTrue(GrouperClientWs.mostRecentRequest,
24669             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
24670         assertTrue(GrouperClientWs.mostRecentRequest,
24671             !GrouperClientWs.mostRecentRequest.contains("actions"));
24672         assertTrue(GrouperClientWs.mostRecentRequest,
24673             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
24674         assertTrue(GrouperClientWs.mostRecentRequest,
24675             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
24676         assertTrue(GrouperClientWs.mostRecentRequest,
24677             !GrouperClientWs.mostRecentRequest.contains("enabled"));
24678         assertTrue(GrouperClientWs.mostRecentRequest,
24679             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
24680         assertTrue(GrouperClientWs.mostRecentRequest,
24681             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
24682         assertTrue(GrouperClientWs.mostRecentRequest,
24683             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
24684         assertTrue(GrouperClientWs.mostRecentRequest,
24685             !GrouperClientWs.mostRecentRequest.contains("params"));
24686         assertTrue(GrouperClientWs.mostRecentRequest,
24687             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
24688         assertTrue(GrouperClientWs.mostRecentRequest,
24689             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
24690         assertTrue(GrouperClientWs.mostRecentRequest,
24691             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
24692         assertTrue(GrouperClientWs.mostRecentRequest,
24693             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
24694         assertTrue(GrouperClientWs.mostRecentRequest,
24695             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
24696         assertTrue(GrouperClientWs.mostRecentRequest,
24697             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
24698         assertTrue(GrouperClientWs.mostRecentRequest,
24699             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
24700         assertTrue(GrouperClientWs.mostRecentRequest,
24701             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
24702         assertTrue(GrouperClientWs.mostRecentRequest,
24703             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
24704         assertTrue(GrouperClientWs.mostRecentRequest,
24705             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
24706         assertFalse(GrouperClientWs.mostRecentRequest,
24707             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
24708         assertFalse(GrouperClientWs.mostRecentRequest,
24709             GrouperClientWs.mostRecentRequest.contains("theValue"));
24710         assertFalse(GrouperClientWs.mostRecentRequest,
24711             GrouperClientWs.mostRecentRequest.contains(">abc<"));
24712         assertTrue(GrouperClientWs.mostRecentRequest,
24713             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
24714         assertFalse(GrouperClientWs.mostRecentRequest,
24715             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
24716         assertTrue(GrouperClientWs.mostRecentRequest,
24717             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
24718         assertTrue(GrouperClientWs.mostRecentRequest,
24719             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
24720         assertTrue(GrouperClientWs.mostRecentRequest,
24721             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
24722         assertTrue(GrouperClientWs.mostRecentRequest,
24723             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
24724         assertTrue(GrouperClientWs.mostRecentRequest,
24725             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
24726         assertTrue(GrouperClientWs.mostRecentRequest,
24727             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
24728 
24729         // ######################################################
24730         // Try group assignment on assignment by attributeDef with wrong id
24731 
24732         baos = new ByteArrayOutputStream();
24733         System.setOut(new PrintStream(baos));
24734 
24735         try {
24736           GrouperClient.main(GrouperClientUtils.splitTrim(
24737               "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --attributeDefUuids=1" + attributeDef2.getId(),
24738               " "));
24739 
24740           System.out.flush();
24741           output = new String(baos.toByteArray());
24742 
24743           System.setOut(systemOut);
24744 
24745           outputLines = GrouperClientUtils.splitTrim(output, "\n");
24746 
24747           // match: Index: 0: attributeAssignType: stem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
24748           // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
24749           pattern = Pattern
24750               .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
24751 
24752           assertEquals(0, GrouperUtil.length(outputLines));
24753           fail("Why did it not fail?");
24754         } catch (Exception e) {
24755           //good
24756         }
24757         assertTrue(GrouperClientWs.mostRecentRequest,
24758             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
24759         assertTrue(GrouperClientWs.mostRecentRequest,
24760             !GrouperClientWs.mostRecentRequest.contains("actions"));
24761         assertTrue(GrouperClientWs.mostRecentRequest,
24762             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
24763         assertTrue(GrouperClientWs.mostRecentRequest,
24764             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
24765         assertTrue(GrouperClientWs.mostRecentRequest,
24766             !GrouperClientWs.mostRecentRequest.contains("enabled"));
24767         assertTrue(GrouperClientWs.mostRecentRequest,
24768             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
24769         assertTrue(GrouperClientWs.mostRecentRequest,
24770             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
24771         assertTrue(GrouperClientWs.mostRecentRequest,
24772             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
24773         assertTrue(GrouperClientWs.mostRecentRequest,
24774             !GrouperClientWs.mostRecentRequest.contains("params"));
24775         assertTrue(GrouperClientWs.mostRecentRequest,
24776             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
24777         assertTrue(GrouperClientWs.mostRecentRequest,
24778             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
24779         assertTrue(GrouperClientWs.mostRecentRequest,
24780             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
24781         assertTrue(GrouperClientWs.mostRecentRequest,
24782             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
24783         assertTrue(GrouperClientWs.mostRecentRequest,
24784             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
24785         assertTrue(GrouperClientWs.mostRecentRequest,
24786             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
24787         assertTrue(GrouperClientWs.mostRecentRequest,
24788             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
24789         assertTrue(GrouperClientWs.mostRecentRequest,
24790             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
24791         assertTrue(GrouperClientWs.mostRecentRequest,
24792             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
24793         assertTrue(GrouperClientWs.mostRecentRequest,
24794             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
24795         assertFalse(GrouperClientWs.mostRecentRequest,
24796             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
24797         assertFalse(GrouperClientWs.mostRecentRequest,
24798             GrouperClientWs.mostRecentRequest.contains("theValue"));
24799         assertFalse(GrouperClientWs.mostRecentRequest,
24800             GrouperClientWs.mostRecentRequest.contains("abc"));
24801         assertTrue(GrouperClientWs.mostRecentRequest,
24802             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
24803         assertFalse(GrouperClientWs.mostRecentRequest,
24804             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
24805         assertTrue(GrouperClientWs.mostRecentRequest,
24806             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
24807         assertTrue(GrouperClientWs.mostRecentRequest,
24808             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
24809         assertTrue(GrouperClientWs.mostRecentRequest,
24810             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
24811         assertTrue(GrouperClientWs.mostRecentRequest,
24812             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
24813         assertTrue(GrouperClientWs.mostRecentRequest,
24814             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
24815         assertTrue(GrouperClientWs.mostRecentRequest,
24816             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
24817 
24818 
24819         // ######################################################
24820         // Try group assignment on assignment by attributeDef and value
24821 
24822         baos = new ByteArrayOutputStream();
24823         System.setOut(new PrintStream(baos));
24824 
24825         GrouperClient.main(GrouperClientUtils.splitTrim(
24826             "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --attributeDefUuids=" + attributeDef2.getId()
24827             + " --attributeDefValueType=integer --value=123 ",
24828           " "));
24829 
24830         System.out.flush();
24831         output = new String(baos.toByteArray());
24832 
24833         System.setOut(systemOut);
24834 
24835         outputLines = GrouperClientUtils.splitTrim(output, "\n");
24836 
24837         // match: Index: 0: attributeAssignType: stem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
24838         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
24839         pattern = Pattern
24840             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
24841 
24842         assertEquals(1, GrouperUtil.length(outputLines));
24843         outputLine = outputLines[0];
24844 
24845         matcher = pattern.matcher(outputLines[0]);
24846 
24847         assertTrue(outputLine, matcher.matches());
24848         assertEquals(outputLine, "0", matcher.group(1));
24849         assertEquals(outputLine, "stem_asgn", matcher.group(2));
24850         assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
24851         assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
24852         assertEquals(outputLine, "assign", matcher.group(5));
24853         assertEquals(outputLine, "123", matcher.group(6));
24854         assertEquals(outputLine, "T", matcher.group(7));
24855         assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
24856 
24857         assertTrue(GrouperClientWs.mostRecentRequest,
24858             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
24859         assertTrue(GrouperClientWs.mostRecentRequest,
24860             !GrouperClientWs.mostRecentRequest.contains("actions"));
24861         assertTrue(GrouperClientWs.mostRecentRequest,
24862             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
24863         assertTrue(GrouperClientWs.mostRecentRequest,
24864             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
24865         assertTrue(GrouperClientWs.mostRecentRequest,
24866             !GrouperClientWs.mostRecentRequest.contains("enabled"));
24867         assertTrue(GrouperClientWs.mostRecentRequest,
24868             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
24869         assertTrue(GrouperClientWs.mostRecentRequest,
24870             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
24871         assertTrue(GrouperClientWs.mostRecentRequest,
24872             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
24873         assertTrue(GrouperClientWs.mostRecentRequest,
24874             !GrouperClientWs.mostRecentRequest.contains("params"));
24875         assertTrue(GrouperClientWs.mostRecentRequest,
24876             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
24877         assertTrue(GrouperClientWs.mostRecentRequest,
24878             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
24879         assertTrue(GrouperClientWs.mostRecentRequest,
24880             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
24881         assertTrue(GrouperClientWs.mostRecentRequest,
24882             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
24883         assertTrue(GrouperClientWs.mostRecentRequest,
24884             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
24885         assertTrue(GrouperClientWs.mostRecentRequest,
24886             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
24887         assertTrue(GrouperClientWs.mostRecentRequest,
24888             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
24889         assertTrue(GrouperClientWs.mostRecentRequest,
24890             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
24891         assertTrue(GrouperClientWs.mostRecentRequest,
24892             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
24893         assertTrue(GrouperClientWs.mostRecentRequest,
24894             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
24895         assertTrue(GrouperClientWs.mostRecentRequest,
24896             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
24897         assertTrue(GrouperClientWs.mostRecentRequest,
24898             GrouperClientWs.mostRecentRequest.contains("theValue"));
24899         assertTrue(GrouperClientWs.mostRecentRequest,
24900             GrouperClientWs.mostRecentRequest.contains(">123<"));
24901         assertTrue(GrouperClientWs.mostRecentRequest,
24902             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
24903         assertFalse(GrouperClientWs.mostRecentRequest,
24904             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
24905         assertTrue(GrouperClientWs.mostRecentRequest,
24906             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
24907         assertTrue(GrouperClientWs.mostRecentRequest,
24908             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
24909         assertTrue(GrouperClientWs.mostRecentRequest,
24910             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
24911         assertTrue(GrouperClientWs.mostRecentRequest,
24912             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
24913         assertTrue(GrouperClientWs.mostRecentRequest,
24914             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
24915         assertTrue(GrouperClientWs.mostRecentRequest,
24916             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
24917 
24918 
24919         // ######################################################
24920         // Try group assignment on assignment by attributeDef and wrong value
24921 
24922         baos = new ByteArrayOutputStream();
24923         System.setOut(new PrintStream(baos));
24924 
24925         GrouperClient.main(GrouperClientUtils.splitTrim(
24926             "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --attributeDefUuids=" + attributeDef2.getId()
24927             + " --attributeDefValueType=integer --value=1234 ",
24928           " "));
24929 
24930         System.out.flush();
24931         output = new String(baos.toByteArray());
24932 
24933         System.setOut(systemOut);
24934 
24935         outputLines = GrouperClientUtils.splitTrim(output, "\n");
24936 
24937         // match: Index: 0: attributeAssignType: stem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
24938         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
24939         pattern = Pattern
24940             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
24941 
24942         assertEquals(0, GrouperUtil.length(outputLines));
24943 
24944         assertTrue(GrouperClientWs.mostRecentRequest,
24945             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
24946         assertTrue(GrouperClientWs.mostRecentRequest,
24947             !GrouperClientWs.mostRecentRequest.contains("actions"));
24948         assertTrue(GrouperClientWs.mostRecentRequest,
24949             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
24950         assertTrue(GrouperClientWs.mostRecentRequest,
24951             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
24952         assertTrue(GrouperClientWs.mostRecentRequest,
24953             !GrouperClientWs.mostRecentRequest.contains("enabled"));
24954         assertTrue(GrouperClientWs.mostRecentRequest,
24955             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
24956         assertTrue(GrouperClientWs.mostRecentRequest,
24957             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
24958         assertTrue(GrouperClientWs.mostRecentRequest,
24959             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
24960         assertTrue(GrouperClientWs.mostRecentRequest,
24961             !GrouperClientWs.mostRecentRequest.contains("params"));
24962         assertTrue(GrouperClientWs.mostRecentRequest,
24963             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
24964         assertTrue(GrouperClientWs.mostRecentRequest,
24965             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
24966         assertTrue(GrouperClientWs.mostRecentRequest,
24967             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
24968         assertTrue(GrouperClientWs.mostRecentRequest,
24969             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
24970         assertTrue(GrouperClientWs.mostRecentRequest,
24971             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
24972         assertTrue(GrouperClientWs.mostRecentRequest,
24973             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
24974         assertTrue(GrouperClientWs.mostRecentRequest,
24975             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
24976         assertTrue(GrouperClientWs.mostRecentRequest,
24977             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
24978         assertTrue(GrouperClientWs.mostRecentRequest,
24979             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
24980         assertTrue(GrouperClientWs.mostRecentRequest,
24981             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
24982         assertTrue(GrouperClientWs.mostRecentRequest,
24983             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
24984         assertTrue(GrouperClientWs.mostRecentRequest,
24985             GrouperClientWs.mostRecentRequest.contains("theValue"));
24986         assertTrue(GrouperClientWs.mostRecentRequest,
24987             GrouperClientWs.mostRecentRequest.contains("1234"));
24988         assertTrue(GrouperClientWs.mostRecentRequest,
24989             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
24990         assertFalse(GrouperClientWs.mostRecentRequest,
24991             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
24992         assertTrue(GrouperClientWs.mostRecentRequest,
24993             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
24994         assertTrue(GrouperClientWs.mostRecentRequest,
24995             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
24996         assertTrue(GrouperClientWs.mostRecentRequest,
24997             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
24998         assertTrue(GrouperClientWs.mostRecentRequest,
24999             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
25000         assertTrue(GrouperClientWs.mostRecentRequest,
25001             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
25002         assertTrue(GrouperClientWs.mostRecentRequest,
25003             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
25004 
25005 
25006         // ######################################################
25007         // Try group assignment on assignment by attributeDef and value
25008 
25009         baos = new ByteArrayOutputStream();
25010         System.setOut(new PrintStream(baos));
25011 
25012         GrouperClient.main(GrouperClientUtils.splitTrim(
25013             "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --attributeDefUuids=" + attributeDef2.getId()
25014             + " --includeAssignmentsFromAssignments=T ",
25015           " "));
25016 
25017         System.out.flush();
25018         output = new String(baos.toByteArray());
25019 
25020         System.setOut(systemOut);
25021 
25022         outputLines = GrouperClientUtils.splitTrim(output, "\n");
25023 
25024         // match: Index: 0: attributeAssignType: stem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
25025         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
25026         pattern = Pattern
25027             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
25028 
25029         assertEquals(2, GrouperUtil.length(outputLines));
25030         outputLine = outputLines[0];
25031 
25032         matcher = pattern.matcher(outputLine);
25033 
25034         assertTrue(outputLine, matcher.matches());
25035         assertEquals(outputLine, "0", matcher.group(1));
25036         assertEquals(outputLine, "stem", matcher.group(2));
25037         assertEquals(outputLine, "test:stemTestAttrAssign", matcher.group(3));
25038         assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
25039         assertEquals(outputLine, "assign", matcher.group(5));
25040         assertEquals(outputLine, "abc", matcher.group(6));
25041         assertEquals(outputLine, "T", matcher.group(7));
25042         assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
25043 
25044         outputLine = outputLines[1];
25045 
25046         matcher = pattern.matcher(outputLine);
25047 
25048         assertTrue(outputLine, matcher.matches());
25049         assertEquals(outputLine, "1", matcher.group(1));
25050         assertEquals(outputLine, "stem_asgn", matcher.group(2));
25051         assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
25052         assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
25053         assertEquals(outputLine, "assign", matcher.group(5));
25054         assertEquals(outputLine, "123", matcher.group(6));
25055         assertEquals(outputLine, "T", matcher.group(7));
25056         assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
25057 
25058         assertTrue(GrouperClientWs.mostRecentRequest,
25059             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
25060         assertTrue(GrouperClientWs.mostRecentRequest,
25061             !GrouperClientWs.mostRecentRequest.contains("actions"));
25062         assertTrue(GrouperClientWs.mostRecentRequest,
25063             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
25064         assertTrue(GrouperClientWs.mostRecentRequest,
25065             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
25066         assertTrue(GrouperClientWs.mostRecentRequest,
25067             !GrouperClientWs.mostRecentRequest.contains("enabled"));
25068         assertTrue(GrouperClientWs.mostRecentRequest,
25069             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
25070         assertTrue(GrouperClientWs.mostRecentRequest,
25071             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
25072         assertTrue(GrouperClientWs.mostRecentRequest,
25073             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
25074         assertTrue(GrouperClientWs.mostRecentRequest,
25075             !GrouperClientWs.mostRecentRequest.contains("params"));
25076         assertTrue(GrouperClientWs.mostRecentRequest,
25077             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
25078         assertTrue(GrouperClientWs.mostRecentRequest,
25079             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
25080         assertTrue(GrouperClientWs.mostRecentRequest,
25081             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
25082         assertTrue(GrouperClientWs.mostRecentRequest,
25083             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
25084         assertTrue(GrouperClientWs.mostRecentRequest,
25085             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
25086         assertTrue(GrouperClientWs.mostRecentRequest,
25087             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
25088         assertTrue(GrouperClientWs.mostRecentRequest,
25089             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
25090         assertTrue(GrouperClientWs.mostRecentRequest,
25091             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
25092         assertTrue(GrouperClientWs.mostRecentRequest,
25093             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
25094         assertTrue(GrouperClientWs.mostRecentRequest,
25095             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
25096         assertFalse(GrouperClientWs.mostRecentRequest,
25097             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
25098         assertFalse(GrouperClientWs.mostRecentRequest,
25099             GrouperClientWs.mostRecentRequest.contains("theValue"));
25100         assertFalse(GrouperClientWs.mostRecentRequest,
25101             GrouperClientWs.mostRecentRequest.contains(">123<"));
25102         assertTrue(GrouperClientWs.mostRecentRequest,
25103             GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
25104         assertFalse(GrouperClientWs.mostRecentRequest,
25105             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
25106         assertTrue(GrouperClientWs.mostRecentRequest,
25107             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
25108         assertTrue(GrouperClientWs.mostRecentRequest,
25109             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
25110         assertTrue(GrouperClientWs.mostRecentRequest,
25111             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
25112         assertTrue(GrouperClientWs.mostRecentRequest,
25113             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
25114         assertTrue(GrouperClientWs.mostRecentRequest,
25115             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
25116         assertTrue(GrouperClientWs.mostRecentRequest,
25117             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
25118 
25119 
25120         // ######################################################
25121         // Try group assignment on assignment by owner attribute assign id with wrong id
25122 
25123         baos = new ByteArrayOutputStream();
25124         System.setOut(new PrintStream(baos));
25125 
25126         try {
25127           GrouperClient.main(GrouperClientUtils.splitTrim(
25128               "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --assignAssignOwnerAttributeAssignUuids=1" + attributeAssign.getId()
25129               ,
25130             " "));
25131 
25132           System.out.flush();
25133           output = new String(baos.toByteArray());
25134 
25135           System.setOut(systemOut);
25136 
25137           outputLines = GrouperClientUtils.splitTrim(output, "\n");
25138 
25139           // match: Index: 0: attributeAssignType: stem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
25140           // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
25141           pattern = Pattern
25142               .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
25143 
25144           assertEquals(0, GrouperUtil.length(outputLines));
25145           fail("Shouldnt get here");
25146         } catch (Exception e) {
25147           //good
25148         } finally {
25149           System.setOut(systemOut);
25150 
25151         }
25152 
25153         assertTrue(GrouperClientWs.mostRecentRequest,
25154             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
25155         assertTrue(GrouperClientWs.mostRecentRequest,
25156             !GrouperClientWs.mostRecentRequest.contains("actions"));
25157         assertTrue(GrouperClientWs.mostRecentRequest,
25158             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
25159         assertTrue(GrouperClientWs.mostRecentRequest,
25160             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
25161         assertTrue(GrouperClientWs.mostRecentRequest,
25162             !GrouperClientWs.mostRecentRequest.contains("enabled"));
25163         assertTrue(GrouperClientWs.mostRecentRequest,
25164             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
25165         assertTrue(GrouperClientWs.mostRecentRequest,
25166             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
25167         assertTrue(GrouperClientWs.mostRecentRequest,
25168             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
25169         assertTrue(GrouperClientWs.mostRecentRequest,
25170             !GrouperClientWs.mostRecentRequest.contains("params"));
25171         assertTrue(GrouperClientWs.mostRecentRequest,
25172             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
25173         assertTrue(GrouperClientWs.mostRecentRequest,
25174             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
25175         assertFalse(GrouperClientWs.mostRecentRequest,
25176             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
25177         assertTrue(GrouperClientWs.mostRecentRequest,
25178             GrouperClientWs.mostRecentRequest.contains("<uuid>"));
25179         assertTrue(GrouperClientWs.mostRecentRequest,
25180             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
25181         assertTrue(GrouperClientWs.mostRecentRequest,
25182             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
25183         assertTrue(GrouperClientWs.mostRecentRequest,
25184             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
25185         assertTrue(GrouperClientWs.mostRecentRequest,
25186             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
25187         assertTrue(GrouperClientWs.mostRecentRequest,
25188             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
25189         assertTrue(GrouperClientWs.mostRecentRequest,
25190             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
25191         assertTrue(GrouperClientWs.mostRecentRequest,
25192             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
25193         assertFalse(GrouperClientWs.mostRecentRequest,
25194             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
25195         assertFalse(GrouperClientWs.mostRecentRequest,
25196             GrouperClientWs.mostRecentRequest.contains("theValue"));
25197         assertFalse(GrouperClientWs.mostRecentRequest,
25198             GrouperClientWs.mostRecentRequest.contains(">123<"));
25199         assertFalse(GrouperClientWs.mostRecentRequest,
25200             GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
25201         assertFalse(GrouperClientWs.mostRecentRequest,
25202             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
25203         assertTrue(GrouperClientWs.mostRecentRequest,
25204             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
25205         assertTrue(GrouperClientWs.mostRecentRequest,
25206             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
25207         assertTrue(GrouperClientWs.mostRecentRequest,
25208             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
25209         assertTrue(GrouperClientWs.mostRecentRequest,
25210             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
25211         assertTrue(GrouperClientWs.mostRecentRequest,
25212             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
25213         assertTrue(GrouperClientWs.mostRecentRequest,
25214             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
25215 
25216         // ######################################################
25217         // Try group assignment on assignment by owner attribute assign id
25218 
25219         baos = new ByteArrayOutputStream();
25220         System.setOut(new PrintStream(baos));
25221 
25222         GrouperClient.main(GrouperClientUtils.splitTrim(
25223             "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --assignAssignOwnerAttributeAssignUuids=" + attributeAssign.getId()
25224             ,
25225           " "));
25226 
25227         System.out.flush();
25228         output = new String(baos.toByteArray());
25229 
25230         System.setOut(systemOut);
25231 
25232         outputLines = GrouperClientUtils.splitTrim(output, "\n");
25233 
25234         // match: Index: 0: attributeAssignType: stem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
25235         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
25236         pattern = Pattern
25237             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
25238 
25239         assertEquals(1, GrouperUtil.length(outputLines));
25240 
25241         outputLine = outputLines[0];
25242 
25243         matcher = pattern.matcher(outputLine);
25244 
25245         assertTrue(outputLine, matcher.matches());
25246         assertEquals(outputLine, "0", matcher.group(1));
25247         assertEquals(outputLine, "stem_asgn", matcher.group(2));
25248         assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
25249         assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
25250         assertEquals(outputLine, "assign", matcher.group(5));
25251         assertEquals(outputLine, "123", matcher.group(6));
25252         assertEquals(outputLine, "T", matcher.group(7));
25253         assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
25254 
25255         assertTrue(GrouperClientWs.mostRecentRequest,
25256             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
25257         assertTrue(GrouperClientWs.mostRecentRequest,
25258             !GrouperClientWs.mostRecentRequest.contains("actions"));
25259         assertTrue(GrouperClientWs.mostRecentRequest,
25260             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
25261         assertTrue(GrouperClientWs.mostRecentRequest,
25262             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
25263         assertTrue(GrouperClientWs.mostRecentRequest,
25264             !GrouperClientWs.mostRecentRequest.contains("enabled"));
25265         assertTrue(GrouperClientWs.mostRecentRequest,
25266             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
25267         assertTrue(GrouperClientWs.mostRecentRequest,
25268             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
25269         assertTrue(GrouperClientWs.mostRecentRequest,
25270             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
25271         assertTrue(GrouperClientWs.mostRecentRequest,
25272             !GrouperClientWs.mostRecentRequest.contains("params"));
25273         assertTrue(GrouperClientWs.mostRecentRequest,
25274             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
25275         assertTrue(GrouperClientWs.mostRecentRequest,
25276             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
25277         assertFalse(GrouperClientWs.mostRecentRequest,
25278             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
25279         assertTrue(GrouperClientWs.mostRecentRequest,
25280             GrouperClientWs.mostRecentRequest.contains("<uuid>"));
25281         assertTrue(GrouperClientWs.mostRecentRequest,
25282             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
25283         assertTrue(GrouperClientWs.mostRecentRequest,
25284             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
25285         assertTrue(GrouperClientWs.mostRecentRequest,
25286             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
25287         assertTrue(GrouperClientWs.mostRecentRequest,
25288             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
25289         assertTrue(GrouperClientWs.mostRecentRequest,
25290             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
25291         assertTrue(GrouperClientWs.mostRecentRequest,
25292             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
25293         assertTrue(GrouperClientWs.mostRecentRequest,
25294             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
25295         assertFalse(GrouperClientWs.mostRecentRequest,
25296             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
25297         assertFalse(GrouperClientWs.mostRecentRequest,
25298             GrouperClientWs.mostRecentRequest.contains("theValue"));
25299         assertFalse(GrouperClientWs.mostRecentRequest,
25300             GrouperClientWs.mostRecentRequest.contains(">123<"));
25301         assertFalse(GrouperClientWs.mostRecentRequest,
25302             GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
25303         assertFalse(GrouperClientWs.mostRecentRequest,
25304             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
25305         assertTrue(GrouperClientWs.mostRecentRequest,
25306             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
25307         assertTrue(GrouperClientWs.mostRecentRequest,
25308             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
25309         assertTrue(GrouperClientWs.mostRecentRequest,
25310             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
25311         assertTrue(GrouperClientWs.mostRecentRequest,
25312             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
25313         assertTrue(GrouperClientWs.mostRecentRequest,
25314             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
25315         assertTrue(GrouperClientWs.mostRecentRequest,
25316             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
25317 
25318 
25319         // ######################################################
25320         // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefLookups
25321 
25322         baos = new ByteArrayOutputStream();
25323         System.setOut(new PrintStream(baos));
25324 
25325         GrouperClient.main(GrouperClientUtils.splitTrim(
25326             "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --assignAssignOwnerNamesOfAttributeDefs=" + attributeDef.getName()
25327             ,
25328           " "));
25329 
25330         System.out.flush();
25331         output = new String(baos.toByteArray());
25332 
25333         System.setOut(systemOut);
25334 
25335         outputLines = GrouperClientUtils.splitTrim(output, "\n");
25336 
25337         // match: Index: 0: attributeAssignType: stem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
25338         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
25339         pattern = Pattern
25340             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
25341 
25342         assertEquals(1, GrouperUtil.length(outputLines));
25343 
25344         outputLine = outputLines[0];
25345 
25346         matcher = pattern.matcher(outputLine);
25347 
25348         assertTrue(outputLine, matcher.matches());
25349         assertEquals(outputLine, "0", matcher.group(1));
25350         assertEquals(outputLine, "stem_asgn", matcher.group(2));
25351         assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
25352         assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
25353         assertEquals(outputLine, "assign", matcher.group(5));
25354         assertEquals(outputLine, "123", matcher.group(6));
25355         assertEquals(outputLine, "T", matcher.group(7));
25356         assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
25357 
25358         assertTrue(GrouperClientWs.mostRecentRequest,
25359             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
25360         assertTrue(GrouperClientWs.mostRecentRequest,
25361             !GrouperClientWs.mostRecentRequest.contains("actions"));
25362         assertTrue(GrouperClientWs.mostRecentRequest,
25363             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
25364         assertTrue(GrouperClientWs.mostRecentRequest,
25365             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
25366         assertTrue(GrouperClientWs.mostRecentRequest,
25367             !GrouperClientWs.mostRecentRequest.contains("enabled"));
25368         assertTrue(GrouperClientWs.mostRecentRequest,
25369             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
25370         assertTrue(GrouperClientWs.mostRecentRequest,
25371             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
25372         assertTrue(GrouperClientWs.mostRecentRequest,
25373             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
25374         assertTrue(GrouperClientWs.mostRecentRequest,
25375             !GrouperClientWs.mostRecentRequest.contains("params"));
25376         assertTrue(GrouperClientWs.mostRecentRequest,
25377             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
25378         assertTrue(GrouperClientWs.mostRecentRequest,
25379             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
25380         assertFalse(GrouperClientWs.mostRecentRequest,
25381             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
25382         assertFalse(GrouperClientWs.mostRecentRequest,
25383             GrouperClientWs.mostRecentRequest.contains("<uuid>"));
25384         assertTrue(GrouperClientWs.mostRecentRequest,
25385             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
25386         assertTrue(GrouperClientWs.mostRecentRequest,
25387             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
25388         assertTrue(GrouperClientWs.mostRecentRequest,
25389             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
25390         assertTrue(GrouperClientWs.mostRecentRequest,
25391             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
25392         assertTrue(GrouperClientWs.mostRecentRequest,
25393             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
25394         assertTrue(GrouperClientWs.mostRecentRequest,
25395             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
25396         assertTrue(GrouperClientWs.mostRecentRequest,
25397             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
25398         assertFalse(GrouperClientWs.mostRecentRequest,
25399             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
25400         assertFalse(GrouperClientWs.mostRecentRequest,
25401             GrouperClientWs.mostRecentRequest.contains("theValue"));
25402         assertFalse(GrouperClientWs.mostRecentRequest,
25403             GrouperClientWs.mostRecentRequest.contains(">123<"));
25404         assertFalse(GrouperClientWs.mostRecentRequest,
25405             GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
25406         assertFalse(GrouperClientWs.mostRecentRequest,
25407             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
25408         assertTrue(GrouperClientWs.mostRecentRequest,
25409             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
25410         assertTrue(GrouperClientWs.mostRecentRequest,
25411             GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
25412         assertTrue(GrouperClientWs.mostRecentRequest,
25413             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
25414         assertTrue(GrouperClientWs.mostRecentRequest,
25415             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
25416         assertTrue(GrouperClientWs.mostRecentRequest,
25417             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
25418         assertTrue(GrouperClientWs.mostRecentRequest,
25419             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
25420 
25421 
25422 
25423         // ######################################################
25424         // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefLookups with wrong name
25425 
25426         baos = new ByteArrayOutputStream();
25427         System.setOut(new PrintStream(baos));
25428 
25429         try {
25430           GrouperClient.main(GrouperClientUtils.splitTrim(
25431               "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --assignAssignOwnerNamesOfAttributeDefs=1" + attributeDef.getName()
25432               ,
25433             " "));
25434 
25435           System.out.flush();
25436           output = new String(baos.toByteArray());
25437 
25438           System.setOut(systemOut);
25439 
25440           outputLines = GrouperClientUtils.splitTrim(output, "\n");
25441 
25442           // match: Index: 0: attributeAssignType: stem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
25443           // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
25444           pattern = Pattern
25445               .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
25446 
25447           assertEquals(0, GrouperUtil.length(outputLines));
25448 
25449           fail("shouldnt get here");
25450         } catch (Exception e) {
25451           //good
25452         } finally {
25453           System.setOut(systemOut);
25454         }
25455 
25456         assertTrue(GrouperClientWs.mostRecentRequest,
25457             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
25458         assertTrue(GrouperClientWs.mostRecentRequest,
25459             !GrouperClientWs.mostRecentRequest.contains("actions"));
25460         assertTrue(GrouperClientWs.mostRecentRequest,
25461             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
25462         assertTrue(GrouperClientWs.mostRecentRequest,
25463             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
25464         assertTrue(GrouperClientWs.mostRecentRequest,
25465             !GrouperClientWs.mostRecentRequest.contains("enabled"));
25466         assertTrue(GrouperClientWs.mostRecentRequest,
25467             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
25468         assertTrue(GrouperClientWs.mostRecentRequest,
25469             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
25470         assertTrue(GrouperClientWs.mostRecentRequest,
25471             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
25472         assertTrue(GrouperClientWs.mostRecentRequest,
25473             !GrouperClientWs.mostRecentRequest.contains("params"));
25474         assertTrue(GrouperClientWs.mostRecentRequest,
25475             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
25476         assertTrue(GrouperClientWs.mostRecentRequest,
25477             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
25478         assertFalse(GrouperClientWs.mostRecentRequest,
25479             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
25480         assertFalse(GrouperClientWs.mostRecentRequest,
25481             GrouperClientWs.mostRecentRequest.contains("<uuid>"));
25482         assertTrue(GrouperClientWs.mostRecentRequest,
25483             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
25484         assertTrue(GrouperClientWs.mostRecentRequest,
25485             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
25486         assertTrue(GrouperClientWs.mostRecentRequest,
25487             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
25488         assertTrue(GrouperClientWs.mostRecentRequest,
25489             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
25490         assertTrue(GrouperClientWs.mostRecentRequest,
25491             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
25492         assertTrue(GrouperClientWs.mostRecentRequest,
25493             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
25494         assertTrue(GrouperClientWs.mostRecentRequest,
25495             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
25496         assertFalse(GrouperClientWs.mostRecentRequest,
25497             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
25498         assertFalse(GrouperClientWs.mostRecentRequest,
25499             GrouperClientWs.mostRecentRequest.contains("theValue"));
25500         assertFalse(GrouperClientWs.mostRecentRequest,
25501             GrouperClientWs.mostRecentRequest.contains(">123<"));
25502         assertFalse(GrouperClientWs.mostRecentRequest,
25503             GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
25504         assertFalse(GrouperClientWs.mostRecentRequest,
25505             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
25506         assertTrue(GrouperClientWs.mostRecentRequest,
25507             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
25508         assertTrue(GrouperClientWs.mostRecentRequest,
25509             GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
25510         assertTrue(GrouperClientWs.mostRecentRequest,
25511             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
25512         assertTrue(GrouperClientWs.mostRecentRequest,
25513             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
25514         assertTrue(GrouperClientWs.mostRecentRequest,
25515             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
25516         assertTrue(GrouperClientWs.mostRecentRequest,
25517             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
25518 
25519 
25520         // ######################################################
25521         // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefLookups
25522 
25523         baos = new ByteArrayOutputStream();
25524         System.setOut(new PrintStream(baos));
25525 
25526         GrouperClient.main(GrouperClientUtils.splitTrim(
25527             "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --assignAssignOwnerUuidsOfAttributeDefs=" + attributeDef.getId()
25528             ,
25529           " "));
25530 
25531         System.out.flush();
25532         output = new String(baos.toByteArray());
25533 
25534         System.setOut(systemOut);
25535 
25536         outputLines = GrouperClientUtils.splitTrim(output, "\n");
25537 
25538         // match: Index: 0: attributeAssignType: stem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
25539         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
25540         pattern = Pattern
25541             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
25542 
25543         assertEquals(1, GrouperUtil.length(outputLines));
25544 
25545         outputLine = outputLines[0];
25546 
25547         matcher = pattern.matcher(outputLine);
25548 
25549         assertTrue(outputLine, matcher.matches());
25550         assertEquals(outputLine, "0", matcher.group(1));
25551         assertEquals(outputLine, "stem_asgn", matcher.group(2));
25552         assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
25553         assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
25554         assertEquals(outputLine, "assign", matcher.group(5));
25555         assertEquals(outputLine, "123", matcher.group(6));
25556         assertEquals(outputLine, "T", matcher.group(7));
25557         assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
25558 
25559         assertTrue(GrouperClientWs.mostRecentRequest,
25560             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
25561         assertTrue(GrouperClientWs.mostRecentRequest,
25562             !GrouperClientWs.mostRecentRequest.contains("actions"));
25563         assertTrue(GrouperClientWs.mostRecentRequest,
25564             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
25565         assertTrue(GrouperClientWs.mostRecentRequest,
25566             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
25567         assertTrue(GrouperClientWs.mostRecentRequest,
25568             !GrouperClientWs.mostRecentRequest.contains("enabled"));
25569         assertTrue(GrouperClientWs.mostRecentRequest,
25570             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
25571         assertTrue(GrouperClientWs.mostRecentRequest,
25572             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
25573         assertTrue(GrouperClientWs.mostRecentRequest,
25574             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
25575         assertTrue(GrouperClientWs.mostRecentRequest,
25576             !GrouperClientWs.mostRecentRequest.contains("params"));
25577         assertTrue(GrouperClientWs.mostRecentRequest,
25578             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
25579         assertTrue(GrouperClientWs.mostRecentRequest,
25580             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
25581         assertFalse(GrouperClientWs.mostRecentRequest,
25582             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
25583         assertTrue(GrouperClientWs.mostRecentRequest,
25584             GrouperClientWs.mostRecentRequest.contains("<uuid>"));
25585         assertTrue(GrouperClientWs.mostRecentRequest,
25586             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
25587         assertTrue(GrouperClientWs.mostRecentRequest,
25588             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
25589         assertTrue(GrouperClientWs.mostRecentRequest,
25590             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
25591         assertTrue(GrouperClientWs.mostRecentRequest,
25592             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
25593         assertTrue(GrouperClientWs.mostRecentRequest,
25594             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
25595         assertTrue(GrouperClientWs.mostRecentRequest,
25596             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
25597         assertTrue(GrouperClientWs.mostRecentRequest,
25598             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
25599         assertFalse(GrouperClientWs.mostRecentRequest,
25600             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
25601         assertFalse(GrouperClientWs.mostRecentRequest,
25602             GrouperClientWs.mostRecentRequest.contains("theValue"));
25603         assertFalse(GrouperClientWs.mostRecentRequest,
25604             GrouperClientWs.mostRecentRequest.contains(">123<"));
25605         assertFalse(GrouperClientWs.mostRecentRequest,
25606             GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
25607         assertFalse(GrouperClientWs.mostRecentRequest,
25608             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
25609         assertTrue(GrouperClientWs.mostRecentRequest,
25610             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
25611         assertTrue(GrouperClientWs.mostRecentRequest,
25612             GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
25613         assertTrue(GrouperClientWs.mostRecentRequest,
25614             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
25615         assertTrue(GrouperClientWs.mostRecentRequest,
25616             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
25617         assertTrue(GrouperClientWs.mostRecentRequest,
25618             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
25619         assertTrue(GrouperClientWs.mostRecentRequest,
25620             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
25621 
25622 
25623         // ######################################################
25624         // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefLookups
25625 
25626         baos = new ByteArrayOutputStream();
25627         System.setOut(new PrintStream(baos));
25628 
25629         GrouperClient.main(GrouperClientUtils.splitTrim(
25630             "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --assignAssignOwnerUuidsOfAttributeDefs=" + attributeDef.getId()
25631             ,
25632           " "));
25633 
25634         System.out.flush();
25635         output = new String(baos.toByteArray());
25636 
25637         System.setOut(systemOut);
25638 
25639         outputLines = GrouperClientUtils.splitTrim(output, "\n");
25640 
25641         // match: Index: 0: attributeAssignType: stem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
25642         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
25643         pattern = Pattern
25644             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
25645 
25646         assertEquals(1, GrouperUtil.length(outputLines));
25647 
25648         outputLine = outputLines[0];
25649 
25650         matcher = pattern.matcher(outputLine);
25651 
25652         assertTrue(outputLine, matcher.matches());
25653         assertEquals(outputLine, "0", matcher.group(1));
25654         assertEquals(outputLine, "stem_asgn", matcher.group(2));
25655         assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
25656         assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
25657         assertEquals(outputLine, "assign", matcher.group(5));
25658         assertEquals(outputLine, "123", matcher.group(6));
25659         assertEquals(outputLine, "T", matcher.group(7));
25660         assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
25661 
25662         assertTrue(GrouperClientWs.mostRecentRequest,
25663             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
25664         assertTrue(GrouperClientWs.mostRecentRequest,
25665             !GrouperClientWs.mostRecentRequest.contains("actions"));
25666         assertTrue(GrouperClientWs.mostRecentRequest,
25667             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
25668         assertTrue(GrouperClientWs.mostRecentRequest,
25669             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
25670         assertTrue(GrouperClientWs.mostRecentRequest,
25671             !GrouperClientWs.mostRecentRequest.contains("enabled"));
25672         assertTrue(GrouperClientWs.mostRecentRequest,
25673             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
25674         assertTrue(GrouperClientWs.mostRecentRequest,
25675             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
25676         assertTrue(GrouperClientWs.mostRecentRequest,
25677             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
25678         assertTrue(GrouperClientWs.mostRecentRequest,
25679             !GrouperClientWs.mostRecentRequest.contains("params"));
25680         assertTrue(GrouperClientWs.mostRecentRequest,
25681             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
25682         assertTrue(GrouperClientWs.mostRecentRequest,
25683             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
25684         assertFalse(GrouperClientWs.mostRecentRequest,
25685             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
25686         assertTrue(GrouperClientWs.mostRecentRequest,
25687             GrouperClientWs.mostRecentRequest.contains("<uuid>"));
25688         assertTrue(GrouperClientWs.mostRecentRequest,
25689             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
25690         assertTrue(GrouperClientWs.mostRecentRequest,
25691             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
25692         assertTrue(GrouperClientWs.mostRecentRequest,
25693             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
25694         assertTrue(GrouperClientWs.mostRecentRequest,
25695             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
25696         assertTrue(GrouperClientWs.mostRecentRequest,
25697             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
25698         assertTrue(GrouperClientWs.mostRecentRequest,
25699             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
25700         assertTrue(GrouperClientWs.mostRecentRequest,
25701             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
25702         assertFalse(GrouperClientWs.mostRecentRequest,
25703             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
25704         assertFalse(GrouperClientWs.mostRecentRequest,
25705             GrouperClientWs.mostRecentRequest.contains("theValue"));
25706         assertFalse(GrouperClientWs.mostRecentRequest,
25707             GrouperClientWs.mostRecentRequest.contains(">123<"));
25708         assertFalse(GrouperClientWs.mostRecentRequest,
25709             GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
25710         assertFalse(GrouperClientWs.mostRecentRequest,
25711             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
25712         assertTrue(GrouperClientWs.mostRecentRequest,
25713             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
25714         assertTrue(GrouperClientWs.mostRecentRequest,
25715             GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
25716         assertTrue(GrouperClientWs.mostRecentRequest,
25717             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
25718         assertTrue(GrouperClientWs.mostRecentRequest,
25719             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
25720         assertTrue(GrouperClientWs.mostRecentRequest,
25721             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
25722         assertTrue(GrouperClientWs.mostRecentRequest,
25723             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
25724 
25725 
25726 
25727         // ######################################################
25728         // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefLookups
25729 
25730         baos = new ByteArrayOutputStream();
25731         System.setOut(new PrintStream(baos));
25732 
25733         try {
25734           GrouperClient.main(GrouperClientUtils.splitTrim(
25735               "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --assignAssignOwnerUuidsOfAttributeDefs=1" + attributeDef.getId()
25736               ,
25737             " "));
25738 
25739           System.out.flush();
25740           output = new String(baos.toByteArray());
25741 
25742           System.setOut(systemOut);
25743 
25744           outputLines = GrouperClientUtils.splitTrim(output, "\n");
25745 
25746           // match: Index: 0: attributeAssignType: stem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
25747           // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
25748           pattern = Pattern
25749               .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
25750 
25751           assertEquals(0, GrouperUtil.length(outputLines));
25752           fail("Shouldnt get here");
25753         } catch (Exception e) {
25754           //good
25755         } finally {
25756 
25757           System.setOut(systemOut);
25758 
25759         }
25760 
25761         assertTrue(GrouperClientWs.mostRecentRequest,
25762             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
25763         assertTrue(GrouperClientWs.mostRecentRequest,
25764             !GrouperClientWs.mostRecentRequest.contains("actions"));
25765         assertTrue(GrouperClientWs.mostRecentRequest,
25766             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
25767         assertTrue(GrouperClientWs.mostRecentRequest,
25768             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
25769         assertTrue(GrouperClientWs.mostRecentRequest,
25770             !GrouperClientWs.mostRecentRequest.contains("enabled"));
25771         assertTrue(GrouperClientWs.mostRecentRequest,
25772             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
25773         assertTrue(GrouperClientWs.mostRecentRequest,
25774             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
25775         assertTrue(GrouperClientWs.mostRecentRequest,
25776             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
25777         assertTrue(GrouperClientWs.mostRecentRequest,
25778             !GrouperClientWs.mostRecentRequest.contains("params"));
25779         assertTrue(GrouperClientWs.mostRecentRequest,
25780             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
25781         assertTrue(GrouperClientWs.mostRecentRequest,
25782             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
25783         assertFalse(GrouperClientWs.mostRecentRequest,
25784             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
25785         assertTrue(GrouperClientWs.mostRecentRequest,
25786             GrouperClientWs.mostRecentRequest.contains("<uuid>"));
25787         assertTrue(GrouperClientWs.mostRecentRequest,
25788             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
25789         assertTrue(GrouperClientWs.mostRecentRequest,
25790             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
25791         assertTrue(GrouperClientWs.mostRecentRequest,
25792             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
25793         assertTrue(GrouperClientWs.mostRecentRequest,
25794             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
25795         assertTrue(GrouperClientWs.mostRecentRequest,
25796             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
25797         assertTrue(GrouperClientWs.mostRecentRequest,
25798             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
25799         assertTrue(GrouperClientWs.mostRecentRequest,
25800             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
25801         assertFalse(GrouperClientWs.mostRecentRequest,
25802             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
25803         assertFalse(GrouperClientWs.mostRecentRequest,
25804             GrouperClientWs.mostRecentRequest.contains("theValue"));
25805         assertFalse(GrouperClientWs.mostRecentRequest,
25806             GrouperClientWs.mostRecentRequest.contains(">123<"));
25807         assertFalse(GrouperClientWs.mostRecentRequest,
25808             GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
25809         assertFalse(GrouperClientWs.mostRecentRequest,
25810             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
25811         assertTrue(GrouperClientWs.mostRecentRequest,
25812             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
25813         assertTrue(GrouperClientWs.mostRecentRequest,
25814             GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
25815         assertTrue(GrouperClientWs.mostRecentRequest,
25816             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
25817         assertTrue(GrouperClientWs.mostRecentRequest,
25818             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
25819         assertTrue(GrouperClientWs.mostRecentRequest,
25820             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
25821         assertTrue(GrouperClientWs.mostRecentRequest,
25822             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
25823 
25824 
25825         // ######################################################
25826         // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups
25827 
25828         baos = new ByteArrayOutputStream();
25829         System.setOut(new PrintStream(baos));
25830 
25831         GrouperClient.main(GrouperClientUtils.splitTrim(
25832             "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --assignAssignOwnerNamesOfAttributeDefNames=" + attributeDefName.getName()
25833             ,
25834           " "));
25835 
25836         System.out.flush();
25837         output = new String(baos.toByteArray());
25838 
25839         System.setOut(systemOut);
25840 
25841         outputLines = GrouperClientUtils.splitTrim(output, "\n");
25842 
25843         // match: Index: 0: attributeAssignType: stem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
25844         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
25845         pattern = Pattern
25846             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
25847 
25848         assertEquals(1, GrouperUtil.length(outputLines));
25849 
25850         outputLine = outputLines[0];
25851 
25852         matcher = pattern.matcher(outputLine);
25853 
25854         assertTrue(outputLine, matcher.matches());
25855         assertEquals(outputLine, "0", matcher.group(1));
25856         assertEquals(outputLine, "stem_asgn", matcher.group(2));
25857         assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
25858         assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
25859         assertEquals(outputLine, "assign", matcher.group(5));
25860         assertEquals(outputLine, "123", matcher.group(6));
25861         assertEquals(outputLine, "T", matcher.group(7));
25862         assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
25863 
25864         assertTrue(GrouperClientWs.mostRecentRequest,
25865             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
25866         assertTrue(GrouperClientWs.mostRecentRequest,
25867             !GrouperClientWs.mostRecentRequest.contains("actions"));
25868         assertTrue(GrouperClientWs.mostRecentRequest,
25869             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
25870         assertTrue(GrouperClientWs.mostRecentRequest,
25871             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
25872         assertTrue(GrouperClientWs.mostRecentRequest,
25873             !GrouperClientWs.mostRecentRequest.contains("enabled"));
25874         assertTrue(GrouperClientWs.mostRecentRequest,
25875             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
25876         assertTrue(GrouperClientWs.mostRecentRequest,
25877             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
25878         assertTrue(GrouperClientWs.mostRecentRequest,
25879             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
25880         assertTrue(GrouperClientWs.mostRecentRequest,
25881             !GrouperClientWs.mostRecentRequest.contains("params"));
25882         assertTrue(GrouperClientWs.mostRecentRequest,
25883             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
25884         assertTrue(GrouperClientWs.mostRecentRequest,
25885             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
25886         assertFalse(GrouperClientWs.mostRecentRequest,
25887             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
25888         assertFalse(GrouperClientWs.mostRecentRequest,
25889             GrouperClientWs.mostRecentRequest.contains("<uuid>"));
25890         assertTrue(GrouperClientWs.mostRecentRequest,
25891             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
25892         assertTrue(GrouperClientWs.mostRecentRequest,
25893             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
25894         assertTrue(GrouperClientWs.mostRecentRequest,
25895             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
25896         assertTrue(GrouperClientWs.mostRecentRequest,
25897             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
25898         assertTrue(GrouperClientWs.mostRecentRequest,
25899             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
25900         assertTrue(GrouperClientWs.mostRecentRequest,
25901             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
25902         assertTrue(GrouperClientWs.mostRecentRequest,
25903             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
25904         assertFalse(GrouperClientWs.mostRecentRequest,
25905             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
25906         assertFalse(GrouperClientWs.mostRecentRequest,
25907             GrouperClientWs.mostRecentRequest.contains("theValue"));
25908         assertFalse(GrouperClientWs.mostRecentRequest,
25909             GrouperClientWs.mostRecentRequest.contains(">123<"));
25910         assertFalse(GrouperClientWs.mostRecentRequest,
25911             GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
25912         assertFalse(GrouperClientWs.mostRecentRequest,
25913             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
25914         assertTrue(GrouperClientWs.mostRecentRequest,
25915             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
25916         assertTrue(GrouperClientWs.mostRecentRequest,
25917             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
25918         assertTrue(GrouperClientWs.mostRecentRequest,
25919             GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
25920         assertTrue(GrouperClientWs.mostRecentRequest,
25921             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
25922 
25923 
25924 
25925         // ######################################################
25926         // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups
25927 
25928         baos = new ByteArrayOutputStream();
25929         System.setOut(new PrintStream(baos));
25930 
25931         try {
25932           GrouperClient.main(GrouperClientUtils.splitTrim(
25933               "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --assignAssignOwnerNamesOfAttributeDefNames=1" + attributeDefName.getName()
25934               ,
25935             " "));
25936 
25937           System.out.flush();
25938           output = new String(baos.toByteArray());
25939 
25940           System.setOut(systemOut);
25941 
25942           outputLines = GrouperClientUtils.splitTrim(output, "\n");
25943 
25944           // match: Index: 0: attributeAssignType: stem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
25945           // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
25946           pattern = Pattern
25947               .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
25948 
25949           assertEquals(0, GrouperUtil.length(outputLines));
25950           fail("Shouldnt get here");
25951 
25952         } catch (Exception e) {
25953           //ok
25954         } finally {
25955 
25956           System.setOut(systemOut);
25957 
25958         }
25959 
25960         assertTrue(GrouperClientWs.mostRecentRequest,
25961             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
25962         assertTrue(GrouperClientWs.mostRecentRequest,
25963             !GrouperClientWs.mostRecentRequest.contains("actions"));
25964         assertTrue(GrouperClientWs.mostRecentRequest,
25965             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
25966         assertTrue(GrouperClientWs.mostRecentRequest,
25967             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
25968         assertTrue(GrouperClientWs.mostRecentRequest,
25969             !GrouperClientWs.mostRecentRequest.contains("enabled"));
25970         assertTrue(GrouperClientWs.mostRecentRequest,
25971             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
25972         assertTrue(GrouperClientWs.mostRecentRequest,
25973             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
25974         assertTrue(GrouperClientWs.mostRecentRequest,
25975             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
25976         assertTrue(GrouperClientWs.mostRecentRequest,
25977             !GrouperClientWs.mostRecentRequest.contains("params"));
25978         assertTrue(GrouperClientWs.mostRecentRequest,
25979             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
25980         assertTrue(GrouperClientWs.mostRecentRequest,
25981             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
25982         assertFalse(GrouperClientWs.mostRecentRequest,
25983             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
25984         assertFalse(GrouperClientWs.mostRecentRequest,
25985             GrouperClientWs.mostRecentRequest.contains("<uuid>"));
25986         assertTrue(GrouperClientWs.mostRecentRequest,
25987             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
25988         assertTrue(GrouperClientWs.mostRecentRequest,
25989             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
25990         assertTrue(GrouperClientWs.mostRecentRequest,
25991             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
25992         assertTrue(GrouperClientWs.mostRecentRequest,
25993             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
25994         assertTrue(GrouperClientWs.mostRecentRequest,
25995             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
25996         assertTrue(GrouperClientWs.mostRecentRequest,
25997             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
25998         assertTrue(GrouperClientWs.mostRecentRequest,
25999             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
26000         assertFalse(GrouperClientWs.mostRecentRequest,
26001             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
26002         assertFalse(GrouperClientWs.mostRecentRequest,
26003             GrouperClientWs.mostRecentRequest.contains("theValue"));
26004         assertFalse(GrouperClientWs.mostRecentRequest,
26005             GrouperClientWs.mostRecentRequest.contains(">123<"));
26006         assertFalse(GrouperClientWs.mostRecentRequest,
26007             GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
26008         assertFalse(GrouperClientWs.mostRecentRequest,
26009             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
26010         assertTrue(GrouperClientWs.mostRecentRequest,
26011             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
26012         assertTrue(GrouperClientWs.mostRecentRequest,
26013             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
26014         assertTrue(GrouperClientWs.mostRecentRequest,
26015             GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
26016         assertTrue(GrouperClientWs.mostRecentRequest,
26017             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
26018 
26019 
26020         // ######################################################
26021         // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups
26022 
26023         baos = new ByteArrayOutputStream();
26024         System.setOut(new PrintStream(baos));
26025 
26026         GrouperClient.main(GrouperClientUtils.splitTrim(
26027             "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
26028             ,
26029           " "));
26030 
26031         System.out.flush();
26032         output = new String(baos.toByteArray());
26033 
26034         System.setOut(systemOut);
26035 
26036         outputLines = GrouperClientUtils.splitTrim(output, "\n");
26037 
26038         // match: Index: 0: attributeAssignType: stem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
26039         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
26040         pattern = Pattern
26041             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
26042 
26043         assertEquals(1, GrouperUtil.length(outputLines));
26044 
26045         outputLine = outputLines[0];
26046 
26047         matcher = pattern.matcher(outputLine);
26048 
26049         assertTrue(outputLine, matcher.matches());
26050         assertEquals(outputLine, "0", matcher.group(1));
26051         assertEquals(outputLine, "stem_asgn", matcher.group(2));
26052         assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
26053         assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
26054         assertEquals(outputLine, "assign", matcher.group(5));
26055         assertEquals(outputLine, "123", matcher.group(6));
26056         assertEquals(outputLine, "T", matcher.group(7));
26057         assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
26058 
26059         assertTrue(GrouperClientWs.mostRecentRequest,
26060             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
26061         assertTrue(GrouperClientWs.mostRecentRequest,
26062             !GrouperClientWs.mostRecentRequest.contains("actions"));
26063         assertTrue(GrouperClientWs.mostRecentRequest,
26064             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
26065         assertTrue(GrouperClientWs.mostRecentRequest,
26066             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
26067         assertTrue(GrouperClientWs.mostRecentRequest,
26068             !GrouperClientWs.mostRecentRequest.contains("enabled"));
26069         assertTrue(GrouperClientWs.mostRecentRequest,
26070             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
26071         assertTrue(GrouperClientWs.mostRecentRequest,
26072             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
26073         assertTrue(GrouperClientWs.mostRecentRequest,
26074             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
26075         assertTrue(GrouperClientWs.mostRecentRequest,
26076             !GrouperClientWs.mostRecentRequest.contains("params"));
26077         assertTrue(GrouperClientWs.mostRecentRequest,
26078             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
26079         assertTrue(GrouperClientWs.mostRecentRequest,
26080             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
26081         assertFalse(GrouperClientWs.mostRecentRequest,
26082             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
26083         assertTrue(GrouperClientWs.mostRecentRequest,
26084             GrouperClientWs.mostRecentRequest.contains("<uuid>"));
26085         assertTrue(GrouperClientWs.mostRecentRequest,
26086             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
26087         assertTrue(GrouperClientWs.mostRecentRequest,
26088             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
26089         assertTrue(GrouperClientWs.mostRecentRequest,
26090             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
26091         assertTrue(GrouperClientWs.mostRecentRequest,
26092             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
26093         assertTrue(GrouperClientWs.mostRecentRequest,
26094             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
26095         assertTrue(GrouperClientWs.mostRecentRequest,
26096             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
26097         assertTrue(GrouperClientWs.mostRecentRequest,
26098             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
26099         assertFalse(GrouperClientWs.mostRecentRequest,
26100             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
26101         assertFalse(GrouperClientWs.mostRecentRequest,
26102             GrouperClientWs.mostRecentRequest.contains("theValue"));
26103         assertFalse(GrouperClientWs.mostRecentRequest,
26104             GrouperClientWs.mostRecentRequest.contains(">123<"));
26105         assertFalse(GrouperClientWs.mostRecentRequest,
26106             GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
26107         assertFalse(GrouperClientWs.mostRecentRequest,
26108             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
26109         assertTrue(GrouperClientWs.mostRecentRequest,
26110             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
26111         assertTrue(GrouperClientWs.mostRecentRequest,
26112             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
26113         assertTrue(GrouperClientWs.mostRecentRequest,
26114             GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
26115         assertTrue(GrouperClientWs.mostRecentRequest,
26116             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
26117 
26118 
26119 
26120         // ######################################################
26121         // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups wrong name
26122 
26123         baos = new ByteArrayOutputStream();
26124         System.setOut(new PrintStream(baos));
26125 
26126         try {
26127           GrouperClient.main(GrouperClientUtils.splitTrim(
26128               "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --assignAssignOwnerUuidsOfAttributeDefNames=1" + attributeDefName.getId()
26129               ,
26130             " "));
26131 
26132           System.out.flush();
26133           output = new String(baos.toByteArray());
26134 
26135           System.setOut(systemOut);
26136 
26137           outputLines = GrouperClientUtils.splitTrim(output, "\n");
26138 
26139           // match: Index: 0: attributeAssignType: stem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
26140           // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
26141           pattern = Pattern
26142               .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
26143 
26144           assertEquals(1, GrouperUtil.length(outputLines));
26145           fail("Shouldnt get here");
26146         } catch (Exception e) {
26147           //good
26148         } finally {
26149 
26150           System.setOut(systemOut);
26151 
26152         }
26153 
26154         assertTrue(GrouperClientWs.mostRecentRequest,
26155             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
26156         assertTrue(GrouperClientWs.mostRecentRequest,
26157             !GrouperClientWs.mostRecentRequest.contains("actions"));
26158         assertTrue(GrouperClientWs.mostRecentRequest,
26159             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
26160         assertTrue(GrouperClientWs.mostRecentRequest,
26161             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
26162         assertTrue(GrouperClientWs.mostRecentRequest,
26163             !GrouperClientWs.mostRecentRequest.contains("enabled"));
26164         assertTrue(GrouperClientWs.mostRecentRequest,
26165             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
26166         assertTrue(GrouperClientWs.mostRecentRequest,
26167             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
26168         assertTrue(GrouperClientWs.mostRecentRequest,
26169             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
26170         assertTrue(GrouperClientWs.mostRecentRequest,
26171             !GrouperClientWs.mostRecentRequest.contains("params"));
26172         assertTrue(GrouperClientWs.mostRecentRequest,
26173             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
26174         assertTrue(GrouperClientWs.mostRecentRequest,
26175             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
26176         assertFalse(GrouperClientWs.mostRecentRequest,
26177             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
26178         assertTrue(GrouperClientWs.mostRecentRequest,
26179             GrouperClientWs.mostRecentRequest.contains("<uuid>"));
26180         assertTrue(GrouperClientWs.mostRecentRequest,
26181             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
26182         assertTrue(GrouperClientWs.mostRecentRequest,
26183             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
26184         assertTrue(GrouperClientWs.mostRecentRequest,
26185             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
26186         assertTrue(GrouperClientWs.mostRecentRequest,
26187             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
26188         assertTrue(GrouperClientWs.mostRecentRequest,
26189             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
26190         assertTrue(GrouperClientWs.mostRecentRequest,
26191             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
26192         assertTrue(GrouperClientWs.mostRecentRequest,
26193             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
26194         assertFalse(GrouperClientWs.mostRecentRequest,
26195             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
26196         assertFalse(GrouperClientWs.mostRecentRequest,
26197             GrouperClientWs.mostRecentRequest.contains("theValue"));
26198         assertFalse(GrouperClientWs.mostRecentRequest,
26199             GrouperClientWs.mostRecentRequest.contains(">123<"));
26200         assertFalse(GrouperClientWs.mostRecentRequest,
26201             GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
26202         assertFalse(GrouperClientWs.mostRecentRequest,
26203             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
26204         assertTrue(GrouperClientWs.mostRecentRequest,
26205             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
26206         assertTrue(GrouperClientWs.mostRecentRequest,
26207             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
26208         assertTrue(GrouperClientWs.mostRecentRequest,
26209             GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
26210         assertTrue(GrouperClientWs.mostRecentRequest,
26211             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
26212 
26213 
26214         // ######################################################
26215         // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups
26216 
26217         baos = new ByteArrayOutputStream();
26218         System.setOut(new PrintStream(baos));
26219 
26220         GrouperClient.main(GrouperClientUtils.splitTrim(
26221             "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
26222             + " --assignAssignOwnerActions=assign",
26223           " "));
26224 
26225         System.out.flush();
26226         output = new String(baos.toByteArray());
26227 
26228         System.setOut(systemOut);
26229 
26230         outputLines = GrouperClientUtils.splitTrim(output, "\n");
26231 
26232         // match: Index: 0: attributeAssignType: stem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
26233         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
26234         pattern = Pattern
26235             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
26236 
26237         assertEquals(1, GrouperUtil.length(outputLines));
26238 
26239         outputLine = outputLines[0];
26240 
26241         matcher = pattern.matcher(outputLine);
26242 
26243         assertTrue(outputLine, matcher.matches());
26244         assertEquals(outputLine, "0", matcher.group(1));
26245         assertEquals(outputLine, "stem_asgn", matcher.group(2));
26246         assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
26247         assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
26248         assertEquals(outputLine, "assign", matcher.group(5));
26249         assertEquals(outputLine, "123", matcher.group(6));
26250         assertEquals(outputLine, "T", matcher.group(7));
26251         assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
26252 
26253         assertTrue(GrouperClientWs.mostRecentRequest,
26254             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
26255         assertTrue(GrouperClientWs.mostRecentRequest,
26256             !GrouperClientWs.mostRecentRequest.contains("<actions>"));
26257         assertTrue(GrouperClientWs.mostRecentRequest,
26258             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
26259         assertTrue(GrouperClientWs.mostRecentRequest,
26260             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
26261         assertTrue(GrouperClientWs.mostRecentRequest,
26262             !GrouperClientWs.mostRecentRequest.contains("enabled"));
26263         assertTrue(GrouperClientWs.mostRecentRequest,
26264             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
26265         assertTrue(GrouperClientWs.mostRecentRequest,
26266             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
26267         assertTrue(GrouperClientWs.mostRecentRequest,
26268             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
26269         assertTrue(GrouperClientWs.mostRecentRequest,
26270             !GrouperClientWs.mostRecentRequest.contains("params"));
26271         assertTrue(GrouperClientWs.mostRecentRequest,
26272             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
26273         assertTrue(GrouperClientWs.mostRecentRequest,
26274             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
26275         assertFalse(GrouperClientWs.mostRecentRequest,
26276             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
26277         assertTrue(GrouperClientWs.mostRecentRequest,
26278             GrouperClientWs.mostRecentRequest.contains("<uuid>"));
26279         assertTrue(GrouperClientWs.mostRecentRequest,
26280             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
26281         assertTrue(GrouperClientWs.mostRecentRequest,
26282             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
26283         assertTrue(GrouperClientWs.mostRecentRequest,
26284             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
26285         assertTrue(GrouperClientWs.mostRecentRequest,
26286             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
26287         assertTrue(GrouperClientWs.mostRecentRequest,
26288             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
26289         assertTrue(GrouperClientWs.mostRecentRequest,
26290             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
26291         assertTrue(GrouperClientWs.mostRecentRequest,
26292             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
26293         assertFalse(GrouperClientWs.mostRecentRequest,
26294             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
26295         assertFalse(GrouperClientWs.mostRecentRequest,
26296             GrouperClientWs.mostRecentRequest.contains("theValue"));
26297         assertFalse(GrouperClientWs.mostRecentRequest,
26298             GrouperClientWs.mostRecentRequest.contains(">123<"));
26299         assertFalse(GrouperClientWs.mostRecentRequest,
26300             GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
26301         assertFalse(GrouperClientWs.mostRecentRequest,
26302             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
26303         assertTrue(GrouperClientWs.mostRecentRequest,
26304             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
26305         assertTrue(GrouperClientWs.mostRecentRequest,
26306             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
26307         assertTrue(GrouperClientWs.mostRecentRequest,
26308             GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
26309         assertTrue(GrouperClientWs.mostRecentRequest,
26310             GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
26311 
26312 
26313         // ######################################################
26314         // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups wrong action
26315 
26316         baos = new ByteArrayOutputStream();
26317         System.setOut(new PrintStream(baos));
26318 
26319         GrouperClient.main(GrouperClientUtils.splitTrim(
26320             "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
26321             + " --assignAssignOwnerActions=assign2",
26322           " "));
26323 
26324         System.out.flush();
26325         output = new String(baos.toByteArray());
26326 
26327         System.setOut(systemOut);
26328 
26329         outputLines = GrouperClientUtils.splitTrim(output, "\n");
26330 
26331         // match: Index: 0: attributeAssignType: stem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
26332         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
26333         pattern = Pattern
26334             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
26335 
26336         assertEquals(0, GrouperUtil.length(outputLines));
26337 
26338         assertTrue(GrouperClientWs.mostRecentRequest,
26339             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
26340         assertTrue(GrouperClientWs.mostRecentRequest,
26341             !GrouperClientWs.mostRecentRequest.contains("<actions>"));
26342         assertTrue(GrouperClientWs.mostRecentRequest,
26343             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
26344         assertTrue(GrouperClientWs.mostRecentRequest,
26345             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
26346         assertTrue(GrouperClientWs.mostRecentRequest,
26347             !GrouperClientWs.mostRecentRequest.contains("enabled"));
26348         assertTrue(GrouperClientWs.mostRecentRequest,
26349             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
26350         assertTrue(GrouperClientWs.mostRecentRequest,
26351             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
26352         assertTrue(GrouperClientWs.mostRecentRequest,
26353             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
26354         assertTrue(GrouperClientWs.mostRecentRequest,
26355             !GrouperClientWs.mostRecentRequest.contains("params"));
26356         assertTrue(GrouperClientWs.mostRecentRequest,
26357             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
26358         assertTrue(GrouperClientWs.mostRecentRequest,
26359             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
26360         assertFalse(GrouperClientWs.mostRecentRequest,
26361             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
26362         assertTrue(GrouperClientWs.mostRecentRequest,
26363             GrouperClientWs.mostRecentRequest.contains("<uuid>"));
26364         assertTrue(GrouperClientWs.mostRecentRequest,
26365             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
26366         assertTrue(GrouperClientWs.mostRecentRequest,
26367             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
26368         assertTrue(GrouperClientWs.mostRecentRequest,
26369             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
26370         assertTrue(GrouperClientWs.mostRecentRequest,
26371             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
26372         assertTrue(GrouperClientWs.mostRecentRequest,
26373             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
26374         assertTrue(GrouperClientWs.mostRecentRequest,
26375             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
26376         assertTrue(GrouperClientWs.mostRecentRequest,
26377             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
26378         assertFalse(GrouperClientWs.mostRecentRequest,
26379             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
26380         assertFalse(GrouperClientWs.mostRecentRequest,
26381             GrouperClientWs.mostRecentRequest.contains("theValue"));
26382         assertFalse(GrouperClientWs.mostRecentRequest,
26383             GrouperClientWs.mostRecentRequest.contains(">123<"));
26384         assertFalse(GrouperClientWs.mostRecentRequest,
26385             GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
26386         assertFalse(GrouperClientWs.mostRecentRequest,
26387             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
26388         assertTrue(GrouperClientWs.mostRecentRequest,
26389             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
26390         assertTrue(GrouperClientWs.mostRecentRequest,
26391             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
26392         assertTrue(GrouperClientWs.mostRecentRequest,
26393             GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
26394         assertTrue(GrouperClientWs.mostRecentRequest,
26395             GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
26396 
26397 
26398 
26399         // ######################################################
26400         // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups
26401 
26402         baos = new ByteArrayOutputStream();
26403         System.setOut(new PrintStream(baos));
26404 
26405         GrouperClient.main(GrouperClientUtils.splitTrim(
26406             "--operation=getAttributeAssignmentsWs --attributeAssignType=stem_asgn --ownerStemNames=" + stem.getName()
26407             ,
26408           " "));
26409 
26410         System.out.flush();
26411         output = new String(baos.toByteArray());
26412 
26413         System.setOut(systemOut);
26414 
26415         outputLines = GrouperClientUtils.splitTrim(output, "\n");
26416 
26417         // match: Index: 0: attributeAssignType: stem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
26418         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
26419         pattern = Pattern
26420             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
26421 
26422         assertEquals(1, GrouperUtil.length(outputLines));
26423 
26424         outputLine = outputLines[0];
26425 
26426         matcher = pattern.matcher(outputLine);
26427 
26428         assertTrue(outputLine, matcher.matches());
26429         assertEquals(outputLine, "0", matcher.group(1));
26430         assertEquals(outputLine, "stem_asgn", matcher.group(2));
26431         assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
26432         assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
26433         assertEquals(outputLine, "assign", matcher.group(5));
26434         assertEquals(outputLine, "123", matcher.group(6));
26435         assertEquals(outputLine, "T", matcher.group(7));
26436         assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
26437 
26438         assertTrue(GrouperClientWs.mostRecentRequest,
26439             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
26440         assertTrue(GrouperClientWs.mostRecentRequest,
26441             !GrouperClientWs.mostRecentRequest.contains("<actions>"));
26442         assertTrue(GrouperClientWs.mostRecentRequest,
26443             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
26444         assertTrue(GrouperClientWs.mostRecentRequest,
26445             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
26446         assertTrue(GrouperClientWs.mostRecentRequest,
26447             !GrouperClientWs.mostRecentRequest.contains("enabled"));
26448         assertTrue(GrouperClientWs.mostRecentRequest,
26449             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
26450         assertTrue(GrouperClientWs.mostRecentRequest,
26451             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
26452         assertTrue(GrouperClientWs.mostRecentRequest,
26453             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
26454         assertTrue(GrouperClientWs.mostRecentRequest,
26455             !GrouperClientWs.mostRecentRequest.contains("params"));
26456         assertTrue(GrouperClientWs.mostRecentRequest,
26457             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
26458         assertTrue(GrouperClientWs.mostRecentRequest,
26459             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
26460         assertFalse(GrouperClientWs.mostRecentRequest,
26461             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
26462         assertFalse(GrouperClientWs.mostRecentRequest,
26463             GrouperClientWs.mostRecentRequest.contains("<uuid>"));
26464         assertTrue(GrouperClientWs.mostRecentRequest,
26465             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
26466         assertTrue(GrouperClientWs.mostRecentRequest,
26467             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
26468         assertTrue(GrouperClientWs.mostRecentRequest,
26469             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
26470         assertTrue(GrouperClientWs.mostRecentRequest,
26471             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
26472         assertTrue(GrouperClientWs.mostRecentRequest,
26473             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
26474         assertTrue(GrouperClientWs.mostRecentRequest,
26475             GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
26476         assertTrue(GrouperClientWs.mostRecentRequest,
26477             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
26478         assertFalse(GrouperClientWs.mostRecentRequest,
26479             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
26480         assertFalse(GrouperClientWs.mostRecentRequest,
26481             GrouperClientWs.mostRecentRequest.contains("theValue"));
26482         assertFalse(GrouperClientWs.mostRecentRequest,
26483             GrouperClientWs.mostRecentRequest.contains(">123<"));
26484         assertFalse(GrouperClientWs.mostRecentRequest,
26485             GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
26486         assertFalse(GrouperClientWs.mostRecentRequest,
26487             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
26488         assertTrue(GrouperClientWs.mostRecentRequest,
26489             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
26490         assertTrue(GrouperClientWs.mostRecentRequest,
26491             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
26492         assertTrue(GrouperClientWs.mostRecentRequest,
26493             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
26494         assertTrue(GrouperClientWs.mostRecentRequest,
26495             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
26496 
26497 
26498       } finally {
26499         System.setOut(systemOut);
26500       }
26501 
26502     }
26503 
26504   /**
26505      * @throws Exception
26506      */
26507     public void testGetAttributeAssignsMemberExtraFeatures() throws Exception {
26508 
26509       AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
26510       AttributeDefName attributeDefName2 = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignAssignName");
26511 
26512       final AttributeDef attributeDef = attributeDefName.getAttributeDef();
26513 
26514       attributeDef.setValueType(AttributeDefValueType.string);
26515       attributeDef.setAssignToMember(true);
26516       attributeDef.store();
26517 
26518       final AttributeDef attributeDef2 = attributeDefName2.getAttributeDef();
26519 
26520       attributeDef2.setAssignToGroup(false);
26521       attributeDef2.setAssignToMemberAssn(true);
26522       attributeDef2.setValueType(AttributeDefValueType.integer);
26523       attributeDef2.store();
26524 
26525       Member member = MemberFinder.findBySubject(GrouperSession.staticGrouperSession(), SubjectTestHelper.SUBJ0, true);
26526 
26527       AttributeAssignResult attributeAssignResult = member.getAttributeDelegate().assignAttribute(attributeDefName);
26528       AttributeAssign attributeAssign = attributeAssignResult.getAttributeAssign();
26529       attributeAssign.getValueDelegate().assignValue("abc");
26530 
26531       AttributeAssignResult attributeAssignResult2 = attributeAssign.getAttributeDelegate().assignAttribute(attributeDefName2);
26532       AttributeAssign attributeAssign2 = attributeAssignResult2.getAttributeAssign();
26533       attributeAssign2.getValueDelegate().assignValue("123");
26534 
26535       PrintStream systemOut = System.out;
26536 
26537       ByteArrayOutputStream baos = new ByteArrayOutputStream();
26538       System.setOut(new PrintStream(baos));
26539 
26540       try {
26541 
26542         GrouperClient.main(GrouperClientUtils.splitTrim(
26543             "--operation=getAttributeAssignmentsWs --attributeAssignType=member " +
26544             "--attributeDefNames=test:testAttributeAssignDefNameDef " +
26545             "--attributeDefValueType=string --value=abc",
26546             " "));
26547         System.out.flush();
26548         String output = new String(baos.toByteArray());
26549 
26550         System.setOut(systemOut);
26551 
26552         String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
26553 
26554         // match: Index: 0: attributeAssignType: group, owner: jdbc - test.subject.0, attributeDefNameName test:testAttributeAssignDefName, action: assign, values: 15,5,5, enable: T, id: a9c83eeb78c04ae5befcea36272d318c
26555         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
26556         Pattern pattern = Pattern
26557             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
26558 
26559         assertEquals(1, GrouperUtil.length(outputLines));
26560         String outputLine = outputLines[0];
26561 
26562         Matcher matcher = pattern.matcher(outputLines[0]);
26563 
26564         assertTrue(outputLine, matcher.matches());
26565         assertEquals(outputLine, "0", matcher.group(1));
26566         assertEquals(outputLine, "member", matcher.group(2));
26567         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(3));
26568         assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
26569         assertEquals(outputLine, "assign", matcher.group(5));
26570         assertEquals(outputLine, "abc", matcher.group(6));
26571         assertEquals(outputLine, "T", matcher.group(7));
26572         assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
26573 
26574         assertTrue(GrouperClientWs.mostRecentRequest,
26575             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
26576         assertTrue(GrouperClientWs.mostRecentRequest,
26577             !GrouperClientWs.mostRecentRequest.contains("actions"));
26578         assertTrue(GrouperClientWs.mostRecentRequest,
26579             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
26580         assertTrue(GrouperClientWs.mostRecentRequest,
26581             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
26582         assertTrue(GrouperClientWs.mostRecentRequest,
26583             !GrouperClientWs.mostRecentRequest.contains("enabled"));
26584         assertTrue(GrouperClientWs.mostRecentRequest,
26585             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
26586         assertTrue(GrouperClientWs.mostRecentRequest,
26587             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
26588         assertTrue(GrouperClientWs.mostRecentRequest,
26589             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
26590         assertTrue(GrouperClientWs.mostRecentRequest,
26591             !GrouperClientWs.mostRecentRequest.contains("params"));
26592         assertTrue(GrouperClientWs.mostRecentRequest,
26593             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
26594         assertTrue(GrouperClientWs.mostRecentRequest,
26595             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
26596         assertTrue(GrouperClientWs.mostRecentRequest,
26597             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
26598         assertTrue(GrouperClientWs.mostRecentRequest,
26599             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
26600         assertTrue(GrouperClientWs.mostRecentRequest,
26601             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
26602         assertTrue(GrouperClientWs.mostRecentRequest,
26603             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
26604         assertTrue(GrouperClientWs.mostRecentRequest,
26605             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
26606         assertTrue(GrouperClientWs.mostRecentRequest,
26607             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
26608         assertTrue(GrouperClientWs.mostRecentRequest,
26609             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
26610         assertTrue(GrouperClientWs.mostRecentRequest,
26611             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
26612         assertTrue(GrouperClientWs.mostRecentRequest,
26613             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
26614         assertTrue(GrouperClientWs.mostRecentRequest,
26615             GrouperClientWs.mostRecentRequest.contains("theValue"));
26616         assertTrue(GrouperClientWs.mostRecentRequest,
26617             GrouperClientWs.mostRecentRequest.contains("abc"));
26618         assertTrue(GrouperClientWs.mostRecentRequest,
26619             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
26620         assertTrue(GrouperClientWs.mostRecentRequest,
26621             !GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
26622         assertTrue(GrouperClientWs.mostRecentRequest,
26623             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
26624         assertTrue(GrouperClientWs.mostRecentRequest,
26625             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
26626         assertTrue(GrouperClientWs.mostRecentRequest,
26627             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
26628         assertTrue(GrouperClientWs.mostRecentRequest,
26629             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
26630         assertTrue(GrouperClientWs.mostRecentRequest,
26631             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
26632         assertTrue(GrouperClientWs.mostRecentRequest,
26633             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
26634 
26635         // ######################################################
26636         // Try wrong value
26637 
26638         baos = new ByteArrayOutputStream();
26639         System.setOut(new PrintStream(baos));
26640 
26641         GrouperClient.main(GrouperClientUtils.splitTrim(
26642             "--operation=getAttributeAssignmentsWs --attributeAssignType=member --attributeDefUuids=" + attributeDef.getId() +
26643             " --attributeDefNames=test:testAttributeAssignDefNameDef " +
26644             "--attributeDefValueType=string --value=123",
26645             " "));
26646 
26647 
26648         System.out.flush();
26649         output = new String(baos.toByteArray());
26650 
26651         System.setOut(systemOut);
26652 
26653         outputLines = GrouperClientUtils.splitTrim(output, "\n");
26654 
26655         assertEquals(0, GrouperUtil.length(outputLines));
26656   //      outputLine = outputLines[0];
26657   //
26658   //      matcher = pattern.matcher(outputLines[0]);
26659 
26660         assertTrue(GrouperClientWs.mostRecentRequest,
26661             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
26662         assertTrue(GrouperClientWs.mostRecentRequest,
26663             !GrouperClientWs.mostRecentRequest.contains("actions"));
26664         assertTrue(GrouperClientWs.mostRecentRequest,
26665             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
26666         assertTrue(GrouperClientWs.mostRecentRequest,
26667             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
26668         assertTrue(GrouperClientWs.mostRecentRequest,
26669             !GrouperClientWs.mostRecentRequest.contains("enabled"));
26670         assertTrue(GrouperClientWs.mostRecentRequest,
26671             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
26672         assertTrue(GrouperClientWs.mostRecentRequest,
26673             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
26674         assertTrue(GrouperClientWs.mostRecentRequest,
26675             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
26676         assertTrue(GrouperClientWs.mostRecentRequest,
26677             !GrouperClientWs.mostRecentRequest.contains("params"));
26678         assertTrue(GrouperClientWs.mostRecentRequest,
26679             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
26680         assertTrue(GrouperClientWs.mostRecentRequest,
26681             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
26682         assertTrue(GrouperClientWs.mostRecentRequest,
26683             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
26684         assertTrue(GrouperClientWs.mostRecentRequest,
26685             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
26686         assertTrue(GrouperClientWs.mostRecentRequest,
26687             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
26688         assertTrue(GrouperClientWs.mostRecentRequest,
26689             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
26690         assertTrue(GrouperClientWs.mostRecentRequest,
26691             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
26692         assertTrue(GrouperClientWs.mostRecentRequest,
26693             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
26694         assertTrue(GrouperClientWs.mostRecentRequest,
26695             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
26696         assertTrue(GrouperClientWs.mostRecentRequest,
26697             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
26698         assertTrue(GrouperClientWs.mostRecentRequest,
26699             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
26700         assertTrue(GrouperClientWs.mostRecentRequest,
26701             GrouperClientWs.mostRecentRequest.contains("theValue"));
26702         assertTrue(GrouperClientWs.mostRecentRequest,
26703             GrouperClientWs.mostRecentRequest.contains(">123<"));
26704         assertTrue(GrouperClientWs.mostRecentRequest,
26705             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
26706         assertTrue(GrouperClientWs.mostRecentRequest,
26707             !GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
26708         assertTrue(GrouperClientWs.mostRecentRequest,
26709             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
26710         assertTrue(GrouperClientWs.mostRecentRequest,
26711             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
26712         assertTrue(GrouperClientWs.mostRecentRequest,
26713             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
26714         assertTrue(GrouperClientWs.mostRecentRequest,
26715             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
26716         assertTrue(GrouperClientWs.mostRecentRequest,
26717             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
26718         assertTrue(GrouperClientWs.mostRecentRequest,
26719             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
26720 
26721 
26722         // ######################################################
26723         // Try wrong id
26724 
26725         baos = new ByteArrayOutputStream();
26726         System.setOut(new PrintStream(baos));
26727 
26728         try {
26729           GrouperClient.main(GrouperClientUtils.splitTrim(
26730               " --operation=getAttributeAssignmentsWs --attributeAssignType=member --attributeDefUuids=123" + attributeDef.getId() +
26731               " --attributeDefNames=test:testAttributeAssignDefNameDef " +
26732               "--attributeDefValueType=string --value=123",
26733               " "));
26734           fail("Shouldnt get here");
26735         } catch (GcWebServiceError gwse) {
26736           //ignore
26737         }
26738 
26739         // ######################################################
26740         // Try correct attributeDefType
26741 
26742         baos = new ByteArrayOutputStream();
26743         System.setOut(new PrintStream(baos));
26744 
26745         GrouperClient.main(GrouperClientUtils.splitTrim(
26746             "--operation=getAttributeAssignmentsWs --attributeAssignType=member --attributeDefUuids=" + attributeDef.getId() +
26747             " --attributeDefValueType=string --value=abc --attributeDefType=attr",
26748             " "));
26749 
26750 
26751         System.out.flush();
26752         output = new String(baos.toByteArray());
26753 
26754         System.setOut(systemOut);
26755 
26756         outputLines = GrouperClientUtils.splitTrim(output, "\n");
26757 
26758         // match: Index: 0: attributeAssignType: group, owner: jdbc - test.subject.0, attributeDefNameName test:testAttributeAssignDefName, action: assign, values: 15,5,5, enable: T, id: a9c83eeb78c04ae5befcea36272d318c
26759         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
26760         pattern = Pattern
26761             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
26762 
26763         assertEquals(1, GrouperUtil.length(outputLines));
26764         outputLine = outputLines[0];
26765 
26766         matcher = pattern.matcher(outputLines[0]);
26767 
26768         assertTrue(outputLine, matcher.matches());
26769         assertEquals(outputLine, "0", matcher.group(1));
26770         assertEquals(outputLine, "member", matcher.group(2));
26771         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(3));
26772         assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
26773         assertEquals(outputLine, "assign", matcher.group(5));
26774         assertEquals(outputLine, "abc", matcher.group(6));
26775         assertEquals(outputLine, "T", matcher.group(7));
26776         assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
26777 
26778         assertTrue(GrouperClientWs.mostRecentRequest,
26779             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
26780         assertTrue(GrouperClientWs.mostRecentRequest,
26781             !GrouperClientWs.mostRecentRequest.contains("actions"));
26782         assertTrue(GrouperClientWs.mostRecentRequest,
26783             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
26784         assertTrue(GrouperClientWs.mostRecentRequest,
26785             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
26786         assertTrue(GrouperClientWs.mostRecentRequest,
26787             !GrouperClientWs.mostRecentRequest.contains("enabled"));
26788         assertTrue(GrouperClientWs.mostRecentRequest,
26789             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
26790         assertTrue(GrouperClientWs.mostRecentRequest,
26791             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
26792         assertTrue(GrouperClientWs.mostRecentRequest,
26793             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
26794         assertTrue(GrouperClientWs.mostRecentRequest,
26795             !GrouperClientWs.mostRecentRequest.contains("params"));
26796         assertTrue(GrouperClientWs.mostRecentRequest,
26797             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
26798         assertTrue(GrouperClientWs.mostRecentRequest,
26799             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
26800         assertTrue(GrouperClientWs.mostRecentRequest,
26801             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
26802         assertTrue(GrouperClientWs.mostRecentRequest,
26803             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
26804         assertTrue(GrouperClientWs.mostRecentRequest,
26805             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
26806         assertTrue(GrouperClientWs.mostRecentRequest,
26807             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
26808         assertTrue(GrouperClientWs.mostRecentRequest,
26809             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
26810         assertTrue(GrouperClientWs.mostRecentRequest,
26811             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
26812         assertTrue(GrouperClientWs.mostRecentRequest,
26813             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
26814         assertTrue(GrouperClientWs.mostRecentRequest,
26815             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
26816         assertTrue(GrouperClientWs.mostRecentRequest,
26817             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
26818         assertTrue(GrouperClientWs.mostRecentRequest,
26819             GrouperClientWs.mostRecentRequest.contains("theValue"));
26820         assertTrue(GrouperClientWs.mostRecentRequest,
26821             GrouperClientWs.mostRecentRequest.contains("abc"));
26822         assertTrue(GrouperClientWs.mostRecentRequest,
26823             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
26824         assertTrue(GrouperClientWs.mostRecentRequest,
26825             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
26826         assertTrue(GrouperClientWs.mostRecentRequest,
26827             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
26828         assertTrue(GrouperClientWs.mostRecentRequest,
26829             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
26830         assertTrue(GrouperClientWs.mostRecentRequest,
26831             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
26832         assertTrue(GrouperClientWs.mostRecentRequest,
26833             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
26834         assertTrue(GrouperClientWs.mostRecentRequest,
26835             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
26836         assertTrue(GrouperClientWs.mostRecentRequest,
26837             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
26838 
26839         // ######################################################
26840         // Try wrong attributeDefType
26841 
26842         baos = new ByteArrayOutputStream();
26843         System.setOut(new PrintStream(baos));
26844 
26845         GrouperClient.main(GrouperClientUtils.splitTrim(
26846             "--operation=getAttributeAssignmentsWs --attributeAssignType=member --attributeDefUuids=" + attributeDef.getId() +
26847             " --attributeDefValueType=string --value=abc --attributeDefType=limit",
26848             " "));
26849 
26850         System.out.flush();
26851         output = new String(baos.toByteArray());
26852 
26853         System.setOut(systemOut);
26854 
26855         outputLines = GrouperClientUtils.splitTrim(output, "\n");
26856 
26857         // match: Index: 0: attributeAssignType: group, owner: jdbc - test.subject.0, attributeDefNameName test:testAttributeAssignDefName, action: assign, values: 15,5,5, enable: T, id: a9c83eeb78c04ae5befcea36272d318c
26858         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
26859         pattern = Pattern
26860             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
26861 
26862         assertEquals(0, GrouperUtil.length(outputLines));
26863 
26864         assertTrue(GrouperClientWs.mostRecentRequest,
26865             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
26866         assertTrue(GrouperClientWs.mostRecentRequest,
26867             !GrouperClientWs.mostRecentRequest.contains("actions"));
26868         assertTrue(GrouperClientWs.mostRecentRequest,
26869             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
26870         assertTrue(GrouperClientWs.mostRecentRequest,
26871             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
26872         assertTrue(GrouperClientWs.mostRecentRequest,
26873             !GrouperClientWs.mostRecentRequest.contains("enabled"));
26874         assertTrue(GrouperClientWs.mostRecentRequest,
26875             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
26876         assertTrue(GrouperClientWs.mostRecentRequest,
26877             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
26878         assertTrue(GrouperClientWs.mostRecentRequest,
26879             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
26880         assertTrue(GrouperClientWs.mostRecentRequest,
26881             !GrouperClientWs.mostRecentRequest.contains("params"));
26882         assertTrue(GrouperClientWs.mostRecentRequest,
26883             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
26884         assertTrue(GrouperClientWs.mostRecentRequest,
26885             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
26886         assertTrue(GrouperClientWs.mostRecentRequest,
26887             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
26888         assertTrue(GrouperClientWs.mostRecentRequest,
26889             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
26890         assertTrue(GrouperClientWs.mostRecentRequest,
26891             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
26892         assertTrue(GrouperClientWs.mostRecentRequest,
26893             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
26894         assertTrue(GrouperClientWs.mostRecentRequest,
26895             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
26896         assertTrue(GrouperClientWs.mostRecentRequest,
26897             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
26898         assertTrue(GrouperClientWs.mostRecentRequest,
26899             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
26900         assertTrue(GrouperClientWs.mostRecentRequest,
26901             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
26902         assertTrue(GrouperClientWs.mostRecentRequest,
26903             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
26904         assertTrue(GrouperClientWs.mostRecentRequest,
26905             GrouperClientWs.mostRecentRequest.contains("theValue"));
26906         assertTrue(GrouperClientWs.mostRecentRequest,
26907             GrouperClientWs.mostRecentRequest.contains("abc"));
26908         assertTrue(GrouperClientWs.mostRecentRequest,
26909             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
26910         assertTrue(GrouperClientWs.mostRecentRequest,
26911             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
26912         assertTrue(GrouperClientWs.mostRecentRequest,
26913             GrouperClientWs.mostRecentRequest.contains("limit"));
26914         assertTrue(GrouperClientWs.mostRecentRequest,
26915             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
26916         assertTrue(GrouperClientWs.mostRecentRequest,
26917             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
26918         assertTrue(GrouperClientWs.mostRecentRequest,
26919             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
26920         assertTrue(GrouperClientWs.mostRecentRequest,
26921             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
26922         assertTrue(GrouperClientWs.mostRecentRequest,
26923             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
26924         assertTrue(GrouperClientWs.mostRecentRequest,
26925             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
26926 
26927         // ######################################################
26928         // Try group assignment on assignment by attributeDef
26929 
26930         baos = new ByteArrayOutputStream();
26931         System.setOut(new PrintStream(baos));
26932 
26933         GrouperClient.main(GrouperClientUtils.splitTrim(
26934             "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --attributeDefUuids=" + attributeDef2.getId(),
26935             " "));
26936 
26937         System.out.flush();
26938         output = new String(baos.toByteArray());
26939 
26940         System.setOut(systemOut);
26941 
26942         outputLines = GrouperClientUtils.splitTrim(output, "\n");
26943 
26944         // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
26945         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
26946         pattern = Pattern
26947             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
26948 
26949         assertEquals(1, GrouperUtil.length(outputLines));
26950         outputLine = outputLines[0];
26951 
26952         matcher = pattern.matcher(outputLines[0]);
26953 
26954         assertTrue(outputLine, matcher.matches());
26955         assertEquals(outputLine, "0", matcher.group(1));
26956         assertEquals(outputLine, "mem_asgn", matcher.group(2));
26957         assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
26958         assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
26959         assertEquals(outputLine, "assign", matcher.group(5));
26960         assertEquals(outputLine, "123", matcher.group(6));
26961         assertEquals(outputLine, "T", matcher.group(7));
26962         assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
26963 
26964         assertTrue(GrouperClientWs.mostRecentRequest,
26965             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
26966         assertTrue(GrouperClientWs.mostRecentRequest,
26967             !GrouperClientWs.mostRecentRequest.contains("actions"));
26968         assertTrue(GrouperClientWs.mostRecentRequest,
26969             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
26970         assertTrue(GrouperClientWs.mostRecentRequest,
26971             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
26972         assertTrue(GrouperClientWs.mostRecentRequest,
26973             !GrouperClientWs.mostRecentRequest.contains("enabled"));
26974         assertTrue(GrouperClientWs.mostRecentRequest,
26975             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
26976         assertTrue(GrouperClientWs.mostRecentRequest,
26977             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
26978         assertTrue(GrouperClientWs.mostRecentRequest,
26979             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
26980         assertTrue(GrouperClientWs.mostRecentRequest,
26981             !GrouperClientWs.mostRecentRequest.contains("params"));
26982         assertTrue(GrouperClientWs.mostRecentRequest,
26983             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
26984         assertTrue(GrouperClientWs.mostRecentRequest,
26985             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
26986         assertTrue(GrouperClientWs.mostRecentRequest,
26987             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
26988         assertTrue(GrouperClientWs.mostRecentRequest,
26989             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
26990         assertTrue(GrouperClientWs.mostRecentRequest,
26991             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
26992         assertTrue(GrouperClientWs.mostRecentRequest,
26993             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
26994         assertTrue(GrouperClientWs.mostRecentRequest,
26995             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
26996         assertTrue(GrouperClientWs.mostRecentRequest,
26997             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
26998         assertTrue(GrouperClientWs.mostRecentRequest,
26999             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
27000         assertTrue(GrouperClientWs.mostRecentRequest,
27001             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
27002         assertFalse(GrouperClientWs.mostRecentRequest,
27003             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
27004         assertFalse(GrouperClientWs.mostRecentRequest,
27005             GrouperClientWs.mostRecentRequest.contains("theValue"));
27006         assertFalse(GrouperClientWs.mostRecentRequest,
27007             GrouperClientWs.mostRecentRequest.contains(">abc<"));
27008         assertTrue(GrouperClientWs.mostRecentRequest,
27009             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
27010         assertFalse(GrouperClientWs.mostRecentRequest,
27011             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
27012         assertTrue(GrouperClientWs.mostRecentRequest,
27013             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
27014         assertTrue(GrouperClientWs.mostRecentRequest,
27015             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
27016         assertTrue(GrouperClientWs.mostRecentRequest,
27017             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
27018         assertTrue(GrouperClientWs.mostRecentRequest,
27019             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
27020         assertTrue(GrouperClientWs.mostRecentRequest,
27021             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
27022         assertTrue(GrouperClientWs.mostRecentRequest,
27023             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
27024 
27025         // ######################################################
27026         // Try group assignment on assignment by attributeDef with wrong id
27027 
27028         baos = new ByteArrayOutputStream();
27029         System.setOut(new PrintStream(baos));
27030 
27031         try {
27032           GrouperClient.main(GrouperClientUtils.splitTrim(
27033               "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --attributeDefUuids=1" + attributeDef2.getId(),
27034               " "));
27035 
27036           System.out.flush();
27037           output = new String(baos.toByteArray());
27038 
27039           System.setOut(systemOut);
27040 
27041           outputLines = GrouperClientUtils.splitTrim(output, "\n");
27042 
27043           // match: Index: 0: attributeAssignType: mem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
27044           // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
27045           pattern = Pattern
27046               .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
27047 
27048           assertEquals(0, GrouperUtil.length(outputLines));
27049           fail("Why did it not fail?");
27050         } catch (Exception e) {
27051           //good
27052         }
27053         assertTrue(GrouperClientWs.mostRecentRequest,
27054             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
27055         assertTrue(GrouperClientWs.mostRecentRequest,
27056             !GrouperClientWs.mostRecentRequest.contains("actions"));
27057         assertTrue(GrouperClientWs.mostRecentRequest,
27058             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
27059         assertTrue(GrouperClientWs.mostRecentRequest,
27060             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
27061         assertTrue(GrouperClientWs.mostRecentRequest,
27062             !GrouperClientWs.mostRecentRequest.contains("enabled"));
27063         assertTrue(GrouperClientWs.mostRecentRequest,
27064             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
27065         assertTrue(GrouperClientWs.mostRecentRequest,
27066             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
27067         assertTrue(GrouperClientWs.mostRecentRequest,
27068             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
27069         assertTrue(GrouperClientWs.mostRecentRequest,
27070             !GrouperClientWs.mostRecentRequest.contains("params"));
27071         assertTrue(GrouperClientWs.mostRecentRequest,
27072             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
27073         assertTrue(GrouperClientWs.mostRecentRequest,
27074             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
27075         assertTrue(GrouperClientWs.mostRecentRequest,
27076             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
27077         assertTrue(GrouperClientWs.mostRecentRequest,
27078             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
27079         assertTrue(GrouperClientWs.mostRecentRequest,
27080             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
27081         assertTrue(GrouperClientWs.mostRecentRequest,
27082             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
27083         assertTrue(GrouperClientWs.mostRecentRequest,
27084             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
27085         assertTrue(GrouperClientWs.mostRecentRequest,
27086             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
27087         assertTrue(GrouperClientWs.mostRecentRequest,
27088             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
27089         assertTrue(GrouperClientWs.mostRecentRequest,
27090             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
27091         assertFalse(GrouperClientWs.mostRecentRequest,
27092             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
27093         assertFalse(GrouperClientWs.mostRecentRequest,
27094             GrouperClientWs.mostRecentRequest.contains("theValue"));
27095         assertFalse(GrouperClientWs.mostRecentRequest,
27096             GrouperClientWs.mostRecentRequest.contains("abc"));
27097         assertTrue(GrouperClientWs.mostRecentRequest,
27098             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
27099         assertFalse(GrouperClientWs.mostRecentRequest,
27100             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
27101         assertTrue(GrouperClientWs.mostRecentRequest,
27102             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
27103         assertTrue(GrouperClientWs.mostRecentRequest,
27104             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
27105         assertTrue(GrouperClientWs.mostRecentRequest,
27106             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
27107         assertTrue(GrouperClientWs.mostRecentRequest,
27108             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
27109         assertTrue(GrouperClientWs.mostRecentRequest,
27110             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
27111         assertTrue(GrouperClientWs.mostRecentRequest,
27112             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
27113 
27114 
27115         // ######################################################
27116         // Try group assignment on assignment by attributeDef and value
27117 
27118         baos = new ByteArrayOutputStream();
27119         System.setOut(new PrintStream(baos));
27120 
27121         GrouperClient.main(GrouperClientUtils.splitTrim(
27122             "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --attributeDefUuids=" + attributeDef2.getId()
27123             + " --attributeDefValueType=integer --value=123 ",
27124           " "));
27125 
27126         System.out.flush();
27127         output = new String(baos.toByteArray());
27128 
27129         System.setOut(systemOut);
27130 
27131         outputLines = GrouperClientUtils.splitTrim(output, "\n");
27132 
27133         // match: Index: 0: attributeAssignType: mem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
27134         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
27135         pattern = Pattern
27136             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
27137 
27138         assertEquals(1, GrouperUtil.length(outputLines));
27139         outputLine = outputLines[0];
27140 
27141         matcher = pattern.matcher(outputLines[0]);
27142 
27143         assertTrue(outputLine, matcher.matches());
27144         assertEquals(outputLine, "0", matcher.group(1));
27145         assertEquals(outputLine, "mem_asgn", matcher.group(2));
27146         assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
27147         assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
27148         assertEquals(outputLine, "assign", matcher.group(5));
27149         assertEquals(outputLine, "123", matcher.group(6));
27150         assertEquals(outputLine, "T", matcher.group(7));
27151         assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
27152 
27153         assertTrue(GrouperClientWs.mostRecentRequest,
27154             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
27155         assertTrue(GrouperClientWs.mostRecentRequest,
27156             !GrouperClientWs.mostRecentRequest.contains("actions"));
27157         assertTrue(GrouperClientWs.mostRecentRequest,
27158             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
27159         assertTrue(GrouperClientWs.mostRecentRequest,
27160             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
27161         assertTrue(GrouperClientWs.mostRecentRequest,
27162             !GrouperClientWs.mostRecentRequest.contains("enabled"));
27163         assertTrue(GrouperClientWs.mostRecentRequest,
27164             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
27165         assertTrue(GrouperClientWs.mostRecentRequest,
27166             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
27167         assertTrue(GrouperClientWs.mostRecentRequest,
27168             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
27169         assertTrue(GrouperClientWs.mostRecentRequest,
27170             !GrouperClientWs.mostRecentRequest.contains("params"));
27171         assertTrue(GrouperClientWs.mostRecentRequest,
27172             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
27173         assertTrue(GrouperClientWs.mostRecentRequest,
27174             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
27175         assertTrue(GrouperClientWs.mostRecentRequest,
27176             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
27177         assertTrue(GrouperClientWs.mostRecentRequest,
27178             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
27179         assertTrue(GrouperClientWs.mostRecentRequest,
27180             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
27181         assertTrue(GrouperClientWs.mostRecentRequest,
27182             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
27183         assertTrue(GrouperClientWs.mostRecentRequest,
27184             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
27185         assertTrue(GrouperClientWs.mostRecentRequest,
27186             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
27187         assertTrue(GrouperClientWs.mostRecentRequest,
27188             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
27189         assertTrue(GrouperClientWs.mostRecentRequest,
27190             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
27191         assertTrue(GrouperClientWs.mostRecentRequest,
27192             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
27193         assertTrue(GrouperClientWs.mostRecentRequest,
27194             GrouperClientWs.mostRecentRequest.contains("theValue"));
27195         assertTrue(GrouperClientWs.mostRecentRequest,
27196             GrouperClientWs.mostRecentRequest.contains(">123<"));
27197         assertTrue(GrouperClientWs.mostRecentRequest,
27198             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
27199         assertFalse(GrouperClientWs.mostRecentRequest,
27200             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
27201         assertTrue(GrouperClientWs.mostRecentRequest,
27202             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
27203         assertTrue(GrouperClientWs.mostRecentRequest,
27204             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
27205         assertTrue(GrouperClientWs.mostRecentRequest,
27206             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
27207         assertTrue(GrouperClientWs.mostRecentRequest,
27208             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
27209         assertTrue(GrouperClientWs.mostRecentRequest,
27210             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
27211         assertTrue(GrouperClientWs.mostRecentRequest,
27212             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
27213 
27214 
27215         // ######################################################
27216         // Try group assignment on assignment by attributeDef and wrong value
27217 
27218         baos = new ByteArrayOutputStream();
27219         System.setOut(new PrintStream(baos));
27220 
27221         GrouperClient.main(GrouperClientUtils.splitTrim(
27222             "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --attributeDefUuids=" + attributeDef2.getId()
27223             + " --attributeDefValueType=integer --value=1234 ",
27224           " "));
27225 
27226         System.out.flush();
27227         output = new String(baos.toByteArray());
27228 
27229         System.setOut(systemOut);
27230 
27231         outputLines = GrouperClientUtils.splitTrim(output, "\n");
27232 
27233         // match: Index: 0: attributeAssignType: mem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
27234         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
27235         pattern = Pattern
27236             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
27237 
27238         assertEquals(0, GrouperUtil.length(outputLines));
27239 
27240         assertTrue(GrouperClientWs.mostRecentRequest,
27241             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
27242         assertTrue(GrouperClientWs.mostRecentRequest,
27243             !GrouperClientWs.mostRecentRequest.contains("actions"));
27244         assertTrue(GrouperClientWs.mostRecentRequest,
27245             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
27246         assertTrue(GrouperClientWs.mostRecentRequest,
27247             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
27248         assertTrue(GrouperClientWs.mostRecentRequest,
27249             !GrouperClientWs.mostRecentRequest.contains("enabled"));
27250         assertTrue(GrouperClientWs.mostRecentRequest,
27251             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
27252         assertTrue(GrouperClientWs.mostRecentRequest,
27253             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
27254         assertTrue(GrouperClientWs.mostRecentRequest,
27255             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
27256         assertTrue(GrouperClientWs.mostRecentRequest,
27257             !GrouperClientWs.mostRecentRequest.contains("params"));
27258         assertTrue(GrouperClientWs.mostRecentRequest,
27259             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
27260         assertTrue(GrouperClientWs.mostRecentRequest,
27261             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
27262         assertTrue(GrouperClientWs.mostRecentRequest,
27263             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
27264         assertTrue(GrouperClientWs.mostRecentRequest,
27265             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
27266         assertTrue(GrouperClientWs.mostRecentRequest,
27267             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
27268         assertTrue(GrouperClientWs.mostRecentRequest,
27269             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
27270         assertTrue(GrouperClientWs.mostRecentRequest,
27271             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
27272         assertTrue(GrouperClientWs.mostRecentRequest,
27273             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
27274         assertTrue(GrouperClientWs.mostRecentRequest,
27275             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
27276         assertTrue(GrouperClientWs.mostRecentRequest,
27277             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
27278         assertTrue(GrouperClientWs.mostRecentRequest,
27279             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
27280         assertTrue(GrouperClientWs.mostRecentRequest,
27281             GrouperClientWs.mostRecentRequest.contains("theValue"));
27282         assertTrue(GrouperClientWs.mostRecentRequest,
27283             GrouperClientWs.mostRecentRequest.contains("1234"));
27284         assertTrue(GrouperClientWs.mostRecentRequest,
27285             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
27286         assertFalse(GrouperClientWs.mostRecentRequest,
27287             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
27288         assertTrue(GrouperClientWs.mostRecentRequest,
27289             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
27290         assertTrue(GrouperClientWs.mostRecentRequest,
27291             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
27292         assertTrue(GrouperClientWs.mostRecentRequest,
27293             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
27294         assertTrue(GrouperClientWs.mostRecentRequest,
27295             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
27296         assertTrue(GrouperClientWs.mostRecentRequest,
27297             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
27298         assertTrue(GrouperClientWs.mostRecentRequest,
27299             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
27300 
27301 
27302         // ######################################################
27303         // Try group assignment on assignment by attributeDef and value
27304 
27305         baos = new ByteArrayOutputStream();
27306         System.setOut(new PrintStream(baos));
27307 
27308         GrouperClient.main(GrouperClientUtils.splitTrim(
27309             "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --attributeDefUuids=" + attributeDef2.getId()
27310             + " --includeAssignmentsFromAssignments=T ",
27311           " "));
27312 
27313         System.out.flush();
27314         output = new String(baos.toByteArray());
27315 
27316         System.setOut(systemOut);
27317 
27318         outputLines = GrouperClientUtils.splitTrim(output, "\n");
27319 
27320         // match: Index: 0: attributeAssignType: mem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
27321         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
27322         pattern = Pattern
27323             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
27324 
27325         assertEquals(2, GrouperUtil.length(outputLines));
27326         outputLine = outputLines[0];
27327 
27328         matcher = pattern.matcher(outputLine);
27329 
27330         assertTrue(outputLine, matcher.matches());
27331         assertEquals(outputLine, "0", matcher.group(1));
27332         assertEquals(outputLine, "mem_asgn", matcher.group(2));
27333         assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
27334         assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
27335         assertEquals(outputLine, "assign", matcher.group(5));
27336         assertEquals(outputLine, "123", matcher.group(6));
27337         assertEquals(outputLine, "T", matcher.group(7));
27338         assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
27339 
27340         outputLine = outputLines[1];
27341 
27342         matcher = pattern.matcher(outputLine);
27343 
27344         assertTrue(outputLine, matcher.matches());
27345         assertEquals(outputLine, "1", matcher.group(1));
27346         assertEquals(outputLine, "member", matcher.group(2));
27347         assertEquals(outputLine, "jdbc - test.subject.0", matcher.group(3));
27348         assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
27349         assertEquals(outputLine, "assign", matcher.group(5));
27350         assertEquals(outputLine, "abc", matcher.group(6));
27351         assertEquals(outputLine, "T", matcher.group(7));
27352         assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
27353 
27354         assertTrue(GrouperClientWs.mostRecentRequest,
27355             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
27356         assertTrue(GrouperClientWs.mostRecentRequest,
27357             !GrouperClientWs.mostRecentRequest.contains("actions"));
27358         assertTrue(GrouperClientWs.mostRecentRequest,
27359             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
27360         assertTrue(GrouperClientWs.mostRecentRequest,
27361             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
27362         assertTrue(GrouperClientWs.mostRecentRequest,
27363             !GrouperClientWs.mostRecentRequest.contains("enabled"));
27364         assertTrue(GrouperClientWs.mostRecentRequest,
27365             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
27366         assertTrue(GrouperClientWs.mostRecentRequest,
27367             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
27368         assertTrue(GrouperClientWs.mostRecentRequest,
27369             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
27370         assertTrue(GrouperClientWs.mostRecentRequest,
27371             !GrouperClientWs.mostRecentRequest.contains("params"));
27372         assertTrue(GrouperClientWs.mostRecentRequest,
27373             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
27374         assertTrue(GrouperClientWs.mostRecentRequest,
27375             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
27376         assertTrue(GrouperClientWs.mostRecentRequest,
27377             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
27378         assertTrue(GrouperClientWs.mostRecentRequest,
27379             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
27380         assertTrue(GrouperClientWs.mostRecentRequest,
27381             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
27382         assertTrue(GrouperClientWs.mostRecentRequest,
27383             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
27384         assertTrue(GrouperClientWs.mostRecentRequest,
27385             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
27386         assertTrue(GrouperClientWs.mostRecentRequest,
27387             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
27388         assertTrue(GrouperClientWs.mostRecentRequest,
27389             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
27390         assertTrue(GrouperClientWs.mostRecentRequest,
27391             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
27392         assertFalse(GrouperClientWs.mostRecentRequest,
27393             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
27394         assertFalse(GrouperClientWs.mostRecentRequest,
27395             GrouperClientWs.mostRecentRequest.contains("theValue"));
27396         assertFalse(GrouperClientWs.mostRecentRequest,
27397             GrouperClientWs.mostRecentRequest.contains(">123<"));
27398         assertTrue(GrouperClientWs.mostRecentRequest,
27399             GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
27400         assertFalse(GrouperClientWs.mostRecentRequest,
27401             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
27402         assertTrue(GrouperClientWs.mostRecentRequest,
27403             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
27404         assertTrue(GrouperClientWs.mostRecentRequest,
27405             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
27406         assertTrue(GrouperClientWs.mostRecentRequest,
27407             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
27408         assertTrue(GrouperClientWs.mostRecentRequest,
27409             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
27410         assertTrue(GrouperClientWs.mostRecentRequest,
27411             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
27412         assertTrue(GrouperClientWs.mostRecentRequest,
27413             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
27414 
27415 
27416         // ######################################################
27417         // Try group assignment on assignment by owner attribute assign id with wrong id
27418 
27419         baos = new ByteArrayOutputStream();
27420         System.setOut(new PrintStream(baos));
27421 
27422         try {
27423           GrouperClient.main(GrouperClientUtils.splitTrim(
27424               "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --assignAssignOwnerAttributeAssignUuids=1" + attributeAssign.getId()
27425               ,
27426             " "));
27427 
27428           System.out.flush();
27429           output = new String(baos.toByteArray());
27430 
27431           System.setOut(systemOut);
27432 
27433           outputLines = GrouperClientUtils.splitTrim(output, "\n");
27434 
27435           // match: Index: 0: attributeAssignType: mem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
27436           // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
27437           pattern = Pattern
27438               .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
27439 
27440           assertEquals(0, GrouperUtil.length(outputLines));
27441           fail("Shouldnt get here");
27442         } catch (Exception e) {
27443           //good
27444         } finally {
27445           System.setOut(systemOut);
27446 
27447         }
27448 
27449         assertTrue(GrouperClientWs.mostRecentRequest,
27450             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
27451         assertTrue(GrouperClientWs.mostRecentRequest,
27452             !GrouperClientWs.mostRecentRequest.contains("actions"));
27453         assertTrue(GrouperClientWs.mostRecentRequest,
27454             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
27455         assertTrue(GrouperClientWs.mostRecentRequest,
27456             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
27457         assertTrue(GrouperClientWs.mostRecentRequest,
27458             !GrouperClientWs.mostRecentRequest.contains("enabled"));
27459         assertTrue(GrouperClientWs.mostRecentRequest,
27460             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
27461         assertTrue(GrouperClientWs.mostRecentRequest,
27462             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
27463         assertTrue(GrouperClientWs.mostRecentRequest,
27464             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
27465         assertTrue(GrouperClientWs.mostRecentRequest,
27466             !GrouperClientWs.mostRecentRequest.contains("params"));
27467         assertTrue(GrouperClientWs.mostRecentRequest,
27468             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
27469         assertTrue(GrouperClientWs.mostRecentRequest,
27470             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
27471         assertFalse(GrouperClientWs.mostRecentRequest,
27472             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
27473         assertTrue(GrouperClientWs.mostRecentRequest,
27474             GrouperClientWs.mostRecentRequest.contains("<uuid>"));
27475         assertTrue(GrouperClientWs.mostRecentRequest,
27476             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
27477         assertTrue(GrouperClientWs.mostRecentRequest,
27478             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
27479         assertTrue(GrouperClientWs.mostRecentRequest,
27480             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
27481         assertTrue(GrouperClientWs.mostRecentRequest,
27482             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
27483         assertTrue(GrouperClientWs.mostRecentRequest,
27484             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
27485         assertTrue(GrouperClientWs.mostRecentRequest,
27486             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
27487         assertTrue(GrouperClientWs.mostRecentRequest,
27488             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
27489         assertFalse(GrouperClientWs.mostRecentRequest,
27490             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
27491         assertFalse(GrouperClientWs.mostRecentRequest,
27492             GrouperClientWs.mostRecentRequest.contains("theValue"));
27493         assertFalse(GrouperClientWs.mostRecentRequest,
27494             GrouperClientWs.mostRecentRequest.contains(">123<"));
27495         assertFalse(GrouperClientWs.mostRecentRequest,
27496             GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
27497         assertFalse(GrouperClientWs.mostRecentRequest,
27498             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
27499         assertTrue(GrouperClientWs.mostRecentRequest,
27500             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
27501         assertTrue(GrouperClientWs.mostRecentRequest,
27502             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
27503         assertTrue(GrouperClientWs.mostRecentRequest,
27504             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
27505         assertTrue(GrouperClientWs.mostRecentRequest,
27506             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
27507         assertTrue(GrouperClientWs.mostRecentRequest,
27508             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
27509         assertTrue(GrouperClientWs.mostRecentRequest,
27510             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
27511 
27512         // ######################################################
27513         // Try group assignment on assignment by owner attribute assign id
27514 
27515         baos = new ByteArrayOutputStream();
27516         System.setOut(new PrintStream(baos));
27517 
27518         GrouperClient.main(GrouperClientUtils.splitTrim(
27519             "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --assignAssignOwnerAttributeAssignUuids=" + attributeAssign.getId()
27520             ,
27521           " "));
27522 
27523         System.out.flush();
27524         output = new String(baos.toByteArray());
27525 
27526         System.setOut(systemOut);
27527 
27528         outputLines = GrouperClientUtils.splitTrim(output, "\n");
27529 
27530         // match: Index: 0: attributeAssignType: mem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
27531         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
27532         pattern = Pattern
27533             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
27534 
27535         assertEquals(1, GrouperUtil.length(outputLines));
27536 
27537         outputLine = outputLines[0];
27538 
27539         matcher = pattern.matcher(outputLine);
27540 
27541         assertTrue(outputLine, matcher.matches());
27542         assertEquals(outputLine, "0", matcher.group(1));
27543         assertEquals(outputLine, "mem_asgn", matcher.group(2));
27544         assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
27545         assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
27546         assertEquals(outputLine, "assign", matcher.group(5));
27547         assertEquals(outputLine, "123", matcher.group(6));
27548         assertEquals(outputLine, "T", matcher.group(7));
27549         assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
27550 
27551         assertTrue(GrouperClientWs.mostRecentRequest,
27552             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
27553         assertTrue(GrouperClientWs.mostRecentRequest,
27554             !GrouperClientWs.mostRecentRequest.contains("actions"));
27555         assertTrue(GrouperClientWs.mostRecentRequest,
27556             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
27557         assertTrue(GrouperClientWs.mostRecentRequest,
27558             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
27559         assertTrue(GrouperClientWs.mostRecentRequest,
27560             !GrouperClientWs.mostRecentRequest.contains("enabled"));
27561         assertTrue(GrouperClientWs.mostRecentRequest,
27562             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
27563         assertTrue(GrouperClientWs.mostRecentRequest,
27564             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
27565         assertTrue(GrouperClientWs.mostRecentRequest,
27566             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
27567         assertTrue(GrouperClientWs.mostRecentRequest,
27568             !GrouperClientWs.mostRecentRequest.contains("params"));
27569         assertTrue(GrouperClientWs.mostRecentRequest,
27570             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
27571         assertTrue(GrouperClientWs.mostRecentRequest,
27572             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
27573         assertFalse(GrouperClientWs.mostRecentRequest,
27574             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
27575         assertTrue(GrouperClientWs.mostRecentRequest,
27576             GrouperClientWs.mostRecentRequest.contains("<uuid>"));
27577         assertTrue(GrouperClientWs.mostRecentRequest,
27578             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
27579         assertTrue(GrouperClientWs.mostRecentRequest,
27580             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
27581         assertTrue(GrouperClientWs.mostRecentRequest,
27582             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
27583         assertTrue(GrouperClientWs.mostRecentRequest,
27584             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
27585         assertTrue(GrouperClientWs.mostRecentRequest,
27586             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
27587         assertTrue(GrouperClientWs.mostRecentRequest,
27588             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
27589         assertTrue(GrouperClientWs.mostRecentRequest,
27590             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
27591         assertFalse(GrouperClientWs.mostRecentRequest,
27592             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
27593         assertFalse(GrouperClientWs.mostRecentRequest,
27594             GrouperClientWs.mostRecentRequest.contains("theValue"));
27595         assertFalse(GrouperClientWs.mostRecentRequest,
27596             GrouperClientWs.mostRecentRequest.contains(">123<"));
27597         assertFalse(GrouperClientWs.mostRecentRequest,
27598             GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
27599         assertFalse(GrouperClientWs.mostRecentRequest,
27600             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
27601         assertTrue(GrouperClientWs.mostRecentRequest,
27602             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
27603         assertTrue(GrouperClientWs.mostRecentRequest,
27604             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
27605         assertTrue(GrouperClientWs.mostRecentRequest,
27606             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
27607         assertTrue(GrouperClientWs.mostRecentRequest,
27608             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
27609         assertTrue(GrouperClientWs.mostRecentRequest,
27610             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
27611         assertTrue(GrouperClientWs.mostRecentRequest,
27612             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
27613 
27614 
27615         // ######################################################
27616         // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefLookups
27617 
27618         baos = new ByteArrayOutputStream();
27619         System.setOut(new PrintStream(baos));
27620 
27621         GrouperClient.main(GrouperClientUtils.splitTrim(
27622             "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --assignAssignOwnerNamesOfAttributeDefs=" + attributeDef.getName()
27623             ,
27624           " "));
27625 
27626         System.out.flush();
27627         output = new String(baos.toByteArray());
27628 
27629         System.setOut(systemOut);
27630 
27631         outputLines = GrouperClientUtils.splitTrim(output, "\n");
27632 
27633         // match: Index: 0: attributeAssignType: mem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
27634         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
27635         pattern = Pattern
27636             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
27637 
27638         assertEquals(1, GrouperUtil.length(outputLines));
27639 
27640         outputLine = outputLines[0];
27641 
27642         matcher = pattern.matcher(outputLine);
27643 
27644         assertTrue(outputLine, matcher.matches());
27645         assertEquals(outputLine, "0", matcher.group(1));
27646         assertEquals(outputLine, "mem_asgn", matcher.group(2));
27647         assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
27648         assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
27649         assertEquals(outputLine, "assign", matcher.group(5));
27650         assertEquals(outputLine, "123", matcher.group(6));
27651         assertEquals(outputLine, "T", matcher.group(7));
27652         assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
27653 
27654         assertTrue(GrouperClientWs.mostRecentRequest,
27655             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
27656         assertTrue(GrouperClientWs.mostRecentRequest,
27657             !GrouperClientWs.mostRecentRequest.contains("actions"));
27658         assertTrue(GrouperClientWs.mostRecentRequest,
27659             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
27660         assertTrue(GrouperClientWs.mostRecentRequest,
27661             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
27662         assertTrue(GrouperClientWs.mostRecentRequest,
27663             !GrouperClientWs.mostRecentRequest.contains("enabled"));
27664         assertTrue(GrouperClientWs.mostRecentRequest,
27665             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
27666         assertTrue(GrouperClientWs.mostRecentRequest,
27667             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
27668         assertTrue(GrouperClientWs.mostRecentRequest,
27669             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
27670         assertTrue(GrouperClientWs.mostRecentRequest,
27671             !GrouperClientWs.mostRecentRequest.contains("params"));
27672         assertTrue(GrouperClientWs.mostRecentRequest,
27673             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
27674         assertTrue(GrouperClientWs.mostRecentRequest,
27675             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
27676         assertFalse(GrouperClientWs.mostRecentRequest,
27677             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
27678         assertFalse(GrouperClientWs.mostRecentRequest,
27679             GrouperClientWs.mostRecentRequest.contains("<uuid>"));
27680         assertTrue(GrouperClientWs.mostRecentRequest,
27681             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
27682         assertTrue(GrouperClientWs.mostRecentRequest,
27683             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
27684         assertTrue(GrouperClientWs.mostRecentRequest,
27685             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
27686         assertTrue(GrouperClientWs.mostRecentRequest,
27687             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
27688         assertTrue(GrouperClientWs.mostRecentRequest,
27689             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
27690         assertTrue(GrouperClientWs.mostRecentRequest,
27691             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
27692         assertTrue(GrouperClientWs.mostRecentRequest,
27693             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
27694         assertFalse(GrouperClientWs.mostRecentRequest,
27695             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
27696         assertFalse(GrouperClientWs.mostRecentRequest,
27697             GrouperClientWs.mostRecentRequest.contains("theValue"));
27698         assertFalse(GrouperClientWs.mostRecentRequest,
27699             GrouperClientWs.mostRecentRequest.contains(">123<"));
27700         assertFalse(GrouperClientWs.mostRecentRequest,
27701             GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
27702         assertFalse(GrouperClientWs.mostRecentRequest,
27703             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
27704         assertTrue(GrouperClientWs.mostRecentRequest,
27705             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
27706         assertTrue(GrouperClientWs.mostRecentRequest,
27707             GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
27708         assertTrue(GrouperClientWs.mostRecentRequest,
27709             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
27710         assertTrue(GrouperClientWs.mostRecentRequest,
27711             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
27712         assertTrue(GrouperClientWs.mostRecentRequest,
27713             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
27714         assertTrue(GrouperClientWs.mostRecentRequest,
27715             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
27716 
27717 
27718 
27719         // ######################################################
27720         // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefLookups with wrong name
27721 
27722         baos = new ByteArrayOutputStream();
27723         System.setOut(new PrintStream(baos));
27724 
27725         try {
27726           GrouperClient.main(GrouperClientUtils.splitTrim(
27727               "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --assignAssignOwnerNamesOfAttributeDefs=1" + attributeDef.getName()
27728               ,
27729             " "));
27730 
27731           System.out.flush();
27732           output = new String(baos.toByteArray());
27733 
27734           System.setOut(systemOut);
27735 
27736           outputLines = GrouperClientUtils.splitTrim(output, "\n");
27737 
27738           // match: Index: 0: attributeAssignType: mem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
27739           // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
27740           pattern = Pattern
27741               .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
27742 
27743           assertEquals(0, GrouperUtil.length(outputLines));
27744 
27745           fail("shouldnt get here");
27746         } catch (Exception e) {
27747           //good
27748         } finally {
27749           System.setOut(systemOut);
27750         }
27751 
27752         assertTrue(GrouperClientWs.mostRecentRequest,
27753             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
27754         assertTrue(GrouperClientWs.mostRecentRequest,
27755             !GrouperClientWs.mostRecentRequest.contains("actions"));
27756         assertTrue(GrouperClientWs.mostRecentRequest,
27757             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
27758         assertTrue(GrouperClientWs.mostRecentRequest,
27759             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
27760         assertTrue(GrouperClientWs.mostRecentRequest,
27761             !GrouperClientWs.mostRecentRequest.contains("enabled"));
27762         assertTrue(GrouperClientWs.mostRecentRequest,
27763             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
27764         assertTrue(GrouperClientWs.mostRecentRequest,
27765             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
27766         assertTrue(GrouperClientWs.mostRecentRequest,
27767             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
27768         assertTrue(GrouperClientWs.mostRecentRequest,
27769             !GrouperClientWs.mostRecentRequest.contains("params"));
27770         assertTrue(GrouperClientWs.mostRecentRequest,
27771             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
27772         assertTrue(GrouperClientWs.mostRecentRequest,
27773             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
27774         assertFalse(GrouperClientWs.mostRecentRequest,
27775             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
27776         assertFalse(GrouperClientWs.mostRecentRequest,
27777             GrouperClientWs.mostRecentRequest.contains("<uuid>"));
27778         assertTrue(GrouperClientWs.mostRecentRequest,
27779             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
27780         assertTrue(GrouperClientWs.mostRecentRequest,
27781             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
27782         assertTrue(GrouperClientWs.mostRecentRequest,
27783             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
27784         assertTrue(GrouperClientWs.mostRecentRequest,
27785             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
27786         assertTrue(GrouperClientWs.mostRecentRequest,
27787             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
27788         assertTrue(GrouperClientWs.mostRecentRequest,
27789             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
27790         assertTrue(GrouperClientWs.mostRecentRequest,
27791             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
27792         assertFalse(GrouperClientWs.mostRecentRequest,
27793             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
27794         assertFalse(GrouperClientWs.mostRecentRequest,
27795             GrouperClientWs.mostRecentRequest.contains("theValue"));
27796         assertFalse(GrouperClientWs.mostRecentRequest,
27797             GrouperClientWs.mostRecentRequest.contains(">123<"));
27798         assertFalse(GrouperClientWs.mostRecentRequest,
27799             GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
27800         assertFalse(GrouperClientWs.mostRecentRequest,
27801             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
27802         assertTrue(GrouperClientWs.mostRecentRequest,
27803             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
27804         assertTrue(GrouperClientWs.mostRecentRequest,
27805             GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
27806         assertTrue(GrouperClientWs.mostRecentRequest,
27807             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
27808         assertTrue(GrouperClientWs.mostRecentRequest,
27809             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
27810         assertTrue(GrouperClientWs.mostRecentRequest,
27811             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
27812         assertTrue(GrouperClientWs.mostRecentRequest,
27813             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
27814 
27815 
27816         // ######################################################
27817         // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefLookups
27818 
27819         baos = new ByteArrayOutputStream();
27820         System.setOut(new PrintStream(baos));
27821 
27822         GrouperClient.main(GrouperClientUtils.splitTrim(
27823             "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --assignAssignOwnerUuidsOfAttributeDefs=" + attributeDef.getId()
27824             ,
27825           " "));
27826 
27827         System.out.flush();
27828         output = new String(baos.toByteArray());
27829 
27830         System.setOut(systemOut);
27831 
27832         outputLines = GrouperClientUtils.splitTrim(output, "\n");
27833 
27834         // match: Index: 0: attributeAssignType: mem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
27835         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
27836         pattern = Pattern
27837             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
27838 
27839         assertEquals(1, GrouperUtil.length(outputLines));
27840 
27841         outputLine = outputLines[0];
27842 
27843         matcher = pattern.matcher(outputLine);
27844 
27845         assertTrue(outputLine, matcher.matches());
27846         assertEquals(outputLine, "0", matcher.group(1));
27847         assertEquals(outputLine, "mem_asgn", matcher.group(2));
27848         assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
27849         assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
27850         assertEquals(outputLine, "assign", matcher.group(5));
27851         assertEquals(outputLine, "123", matcher.group(6));
27852         assertEquals(outputLine, "T", matcher.group(7));
27853         assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
27854 
27855         assertTrue(GrouperClientWs.mostRecentRequest,
27856             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
27857         assertTrue(GrouperClientWs.mostRecentRequest,
27858             !GrouperClientWs.mostRecentRequest.contains("actions"));
27859         assertTrue(GrouperClientWs.mostRecentRequest,
27860             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
27861         assertTrue(GrouperClientWs.mostRecentRequest,
27862             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
27863         assertTrue(GrouperClientWs.mostRecentRequest,
27864             !GrouperClientWs.mostRecentRequest.contains("enabled"));
27865         assertTrue(GrouperClientWs.mostRecentRequest,
27866             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
27867         assertTrue(GrouperClientWs.mostRecentRequest,
27868             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
27869         assertTrue(GrouperClientWs.mostRecentRequest,
27870             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
27871         assertTrue(GrouperClientWs.mostRecentRequest,
27872             !GrouperClientWs.mostRecentRequest.contains("params"));
27873         assertTrue(GrouperClientWs.mostRecentRequest,
27874             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
27875         assertTrue(GrouperClientWs.mostRecentRequest,
27876             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
27877         assertFalse(GrouperClientWs.mostRecentRequest,
27878             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
27879         assertTrue(GrouperClientWs.mostRecentRequest,
27880             GrouperClientWs.mostRecentRequest.contains("<uuid>"));
27881         assertTrue(GrouperClientWs.mostRecentRequest,
27882             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
27883         assertTrue(GrouperClientWs.mostRecentRequest,
27884             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
27885         assertTrue(GrouperClientWs.mostRecentRequest,
27886             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
27887         assertTrue(GrouperClientWs.mostRecentRequest,
27888             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
27889         assertTrue(GrouperClientWs.mostRecentRequest,
27890             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
27891         assertTrue(GrouperClientWs.mostRecentRequest,
27892             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
27893         assertTrue(GrouperClientWs.mostRecentRequest,
27894             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
27895         assertFalse(GrouperClientWs.mostRecentRequest,
27896             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
27897         assertFalse(GrouperClientWs.mostRecentRequest,
27898             GrouperClientWs.mostRecentRequest.contains("theValue"));
27899         assertFalse(GrouperClientWs.mostRecentRequest,
27900             GrouperClientWs.mostRecentRequest.contains(">123<"));
27901         assertFalse(GrouperClientWs.mostRecentRequest,
27902             GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
27903         assertFalse(GrouperClientWs.mostRecentRequest,
27904             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
27905         assertTrue(GrouperClientWs.mostRecentRequest,
27906             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
27907         assertTrue(GrouperClientWs.mostRecentRequest,
27908             GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
27909         assertTrue(GrouperClientWs.mostRecentRequest,
27910             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
27911         assertTrue(GrouperClientWs.mostRecentRequest,
27912             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
27913         assertTrue(GrouperClientWs.mostRecentRequest,
27914             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
27915         assertTrue(GrouperClientWs.mostRecentRequest,
27916             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
27917 
27918 
27919         // ######################################################
27920         // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefLookups
27921 
27922         baos = new ByteArrayOutputStream();
27923         System.setOut(new PrintStream(baos));
27924 
27925         GrouperClient.main(GrouperClientUtils.splitTrim(
27926             "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --assignAssignOwnerUuidsOfAttributeDefs=" + attributeDef.getId()
27927             ,
27928           " "));
27929 
27930         System.out.flush();
27931         output = new String(baos.toByteArray());
27932 
27933         System.setOut(systemOut);
27934 
27935         outputLines = GrouperClientUtils.splitTrim(output, "\n");
27936 
27937         // match: Index: 0: attributeAssignType: mem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
27938         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
27939         pattern = Pattern
27940             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
27941 
27942         assertEquals(1, GrouperUtil.length(outputLines));
27943 
27944         outputLine = outputLines[0];
27945 
27946         matcher = pattern.matcher(outputLine);
27947 
27948         assertTrue(outputLine, matcher.matches());
27949         assertEquals(outputLine, "0", matcher.group(1));
27950         assertEquals(outputLine, "mem_asgn", matcher.group(2));
27951         assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
27952         assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
27953         assertEquals(outputLine, "assign", matcher.group(5));
27954         assertEquals(outputLine, "123", matcher.group(6));
27955         assertEquals(outputLine, "T", matcher.group(7));
27956         assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
27957 
27958         assertTrue(GrouperClientWs.mostRecentRequest,
27959             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
27960         assertTrue(GrouperClientWs.mostRecentRequest,
27961             !GrouperClientWs.mostRecentRequest.contains("actions"));
27962         assertTrue(GrouperClientWs.mostRecentRequest,
27963             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
27964         assertTrue(GrouperClientWs.mostRecentRequest,
27965             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
27966         assertTrue(GrouperClientWs.mostRecentRequest,
27967             !GrouperClientWs.mostRecentRequest.contains("enabled"));
27968         assertTrue(GrouperClientWs.mostRecentRequest,
27969             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
27970         assertTrue(GrouperClientWs.mostRecentRequest,
27971             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
27972         assertTrue(GrouperClientWs.mostRecentRequest,
27973             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
27974         assertTrue(GrouperClientWs.mostRecentRequest,
27975             !GrouperClientWs.mostRecentRequest.contains("params"));
27976         assertTrue(GrouperClientWs.mostRecentRequest,
27977             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
27978         assertTrue(GrouperClientWs.mostRecentRequest,
27979             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
27980         assertFalse(GrouperClientWs.mostRecentRequest,
27981             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
27982         assertTrue(GrouperClientWs.mostRecentRequest,
27983             GrouperClientWs.mostRecentRequest.contains("<uuid>"));
27984         assertTrue(GrouperClientWs.mostRecentRequest,
27985             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
27986         assertTrue(GrouperClientWs.mostRecentRequest,
27987             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
27988         assertTrue(GrouperClientWs.mostRecentRequest,
27989             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
27990         assertTrue(GrouperClientWs.mostRecentRequest,
27991             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
27992         assertTrue(GrouperClientWs.mostRecentRequest,
27993             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
27994         assertTrue(GrouperClientWs.mostRecentRequest,
27995             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
27996         assertTrue(GrouperClientWs.mostRecentRequest,
27997             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
27998         assertFalse(GrouperClientWs.mostRecentRequest,
27999             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
28000         assertFalse(GrouperClientWs.mostRecentRequest,
28001             GrouperClientWs.mostRecentRequest.contains("theValue"));
28002         assertFalse(GrouperClientWs.mostRecentRequest,
28003             GrouperClientWs.mostRecentRequest.contains(">123<"));
28004         assertFalse(GrouperClientWs.mostRecentRequest,
28005             GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
28006         assertFalse(GrouperClientWs.mostRecentRequest,
28007             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
28008         assertTrue(GrouperClientWs.mostRecentRequest,
28009             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
28010         assertTrue(GrouperClientWs.mostRecentRequest,
28011             GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
28012         assertTrue(GrouperClientWs.mostRecentRequest,
28013             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
28014         assertTrue(GrouperClientWs.mostRecentRequest,
28015             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
28016         assertTrue(GrouperClientWs.mostRecentRequest,
28017             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
28018         assertTrue(GrouperClientWs.mostRecentRequest,
28019             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
28020 
28021 
28022 
28023         // ######################################################
28024         // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefLookups
28025 
28026         baos = new ByteArrayOutputStream();
28027         System.setOut(new PrintStream(baos));
28028 
28029         try {
28030           GrouperClient.main(GrouperClientUtils.splitTrim(
28031               "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --assignAssignOwnerUuidsOfAttributeDefs=1" + attributeDef.getId()
28032               ,
28033             " "));
28034 
28035           System.out.flush();
28036           output = new String(baos.toByteArray());
28037 
28038           System.setOut(systemOut);
28039 
28040           outputLines = GrouperClientUtils.splitTrim(output, "\n");
28041 
28042           // match: Index: 0: attributeAssignType: mem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
28043           // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
28044           pattern = Pattern
28045               .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
28046 
28047           assertEquals(0, GrouperUtil.length(outputLines));
28048           fail("Shouldnt get here");
28049         } catch (Exception e) {
28050           //good
28051         } finally {
28052 
28053           System.setOut(systemOut);
28054 
28055         }
28056 
28057         assertTrue(GrouperClientWs.mostRecentRequest,
28058             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
28059         assertTrue(GrouperClientWs.mostRecentRequest,
28060             !GrouperClientWs.mostRecentRequest.contains("actions"));
28061         assertTrue(GrouperClientWs.mostRecentRequest,
28062             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
28063         assertTrue(GrouperClientWs.mostRecentRequest,
28064             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
28065         assertTrue(GrouperClientWs.mostRecentRequest,
28066             !GrouperClientWs.mostRecentRequest.contains("enabled"));
28067         assertTrue(GrouperClientWs.mostRecentRequest,
28068             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
28069         assertTrue(GrouperClientWs.mostRecentRequest,
28070             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
28071         assertTrue(GrouperClientWs.mostRecentRequest,
28072             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
28073         assertTrue(GrouperClientWs.mostRecentRequest,
28074             !GrouperClientWs.mostRecentRequest.contains("params"));
28075         assertTrue(GrouperClientWs.mostRecentRequest,
28076             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
28077         assertTrue(GrouperClientWs.mostRecentRequest,
28078             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
28079         assertFalse(GrouperClientWs.mostRecentRequest,
28080             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
28081         assertTrue(GrouperClientWs.mostRecentRequest,
28082             GrouperClientWs.mostRecentRequest.contains("<uuid>"));
28083         assertTrue(GrouperClientWs.mostRecentRequest,
28084             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
28085         assertTrue(GrouperClientWs.mostRecentRequest,
28086             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
28087         assertTrue(GrouperClientWs.mostRecentRequest,
28088             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
28089         assertTrue(GrouperClientWs.mostRecentRequest,
28090             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
28091         assertTrue(GrouperClientWs.mostRecentRequest,
28092             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
28093         assertTrue(GrouperClientWs.mostRecentRequest,
28094             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
28095         assertTrue(GrouperClientWs.mostRecentRequest,
28096             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
28097         assertFalse(GrouperClientWs.mostRecentRequest,
28098             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
28099         assertFalse(GrouperClientWs.mostRecentRequest,
28100             GrouperClientWs.mostRecentRequest.contains("theValue"));
28101         assertFalse(GrouperClientWs.mostRecentRequest,
28102             GrouperClientWs.mostRecentRequest.contains(">123<"));
28103         assertFalse(GrouperClientWs.mostRecentRequest,
28104             GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
28105         assertFalse(GrouperClientWs.mostRecentRequest,
28106             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
28107         assertTrue(GrouperClientWs.mostRecentRequest,
28108             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
28109         assertTrue(GrouperClientWs.mostRecentRequest,
28110             GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
28111         assertTrue(GrouperClientWs.mostRecentRequest,
28112             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
28113         assertTrue(GrouperClientWs.mostRecentRequest,
28114             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
28115         assertTrue(GrouperClientWs.mostRecentRequest,
28116             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
28117         assertTrue(GrouperClientWs.mostRecentRequest,
28118             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
28119 
28120 
28121         // ######################################################
28122         // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups
28123 
28124         baos = new ByteArrayOutputStream();
28125         System.setOut(new PrintStream(baos));
28126 
28127         GrouperClient.main(GrouperClientUtils.splitTrim(
28128             "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --assignAssignOwnerNamesOfAttributeDefNames=" + attributeDefName.getName()
28129             ,
28130           " "));
28131 
28132         System.out.flush();
28133         output = new String(baos.toByteArray());
28134 
28135         System.setOut(systemOut);
28136 
28137         outputLines = GrouperClientUtils.splitTrim(output, "\n");
28138 
28139         // match: Index: 0: attributeAssignType: mem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
28140         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
28141         pattern = Pattern
28142             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
28143 
28144         assertEquals(1, GrouperUtil.length(outputLines));
28145 
28146         outputLine = outputLines[0];
28147 
28148         matcher = pattern.matcher(outputLine);
28149 
28150         assertTrue(outputLine, matcher.matches());
28151         assertEquals(outputLine, "0", matcher.group(1));
28152         assertEquals(outputLine, "mem_asgn", matcher.group(2));
28153         assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
28154         assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
28155         assertEquals(outputLine, "assign", matcher.group(5));
28156         assertEquals(outputLine, "123", matcher.group(6));
28157         assertEquals(outputLine, "T", matcher.group(7));
28158         assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
28159 
28160         assertTrue(GrouperClientWs.mostRecentRequest,
28161             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
28162         assertTrue(GrouperClientWs.mostRecentRequest,
28163             !GrouperClientWs.mostRecentRequest.contains("actions"));
28164         assertTrue(GrouperClientWs.mostRecentRequest,
28165             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
28166         assertTrue(GrouperClientWs.mostRecentRequest,
28167             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
28168         assertTrue(GrouperClientWs.mostRecentRequest,
28169             !GrouperClientWs.mostRecentRequest.contains("enabled"));
28170         assertTrue(GrouperClientWs.mostRecentRequest,
28171             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
28172         assertTrue(GrouperClientWs.mostRecentRequest,
28173             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
28174         assertTrue(GrouperClientWs.mostRecentRequest,
28175             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
28176         assertTrue(GrouperClientWs.mostRecentRequest,
28177             !GrouperClientWs.mostRecentRequest.contains("params"));
28178         assertTrue(GrouperClientWs.mostRecentRequest,
28179             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
28180         assertTrue(GrouperClientWs.mostRecentRequest,
28181             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
28182         assertFalse(GrouperClientWs.mostRecentRequest,
28183             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
28184         assertFalse(GrouperClientWs.mostRecentRequest,
28185             GrouperClientWs.mostRecentRequest.contains("<uuid>"));
28186         assertTrue(GrouperClientWs.mostRecentRequest,
28187             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
28188         assertTrue(GrouperClientWs.mostRecentRequest,
28189             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
28190         assertTrue(GrouperClientWs.mostRecentRequest,
28191             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
28192         assertTrue(GrouperClientWs.mostRecentRequest,
28193             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
28194         assertTrue(GrouperClientWs.mostRecentRequest,
28195             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
28196         assertTrue(GrouperClientWs.mostRecentRequest,
28197             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
28198         assertTrue(GrouperClientWs.mostRecentRequest,
28199             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
28200         assertFalse(GrouperClientWs.mostRecentRequest,
28201             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
28202         assertFalse(GrouperClientWs.mostRecentRequest,
28203             GrouperClientWs.mostRecentRequest.contains("theValue"));
28204         assertFalse(GrouperClientWs.mostRecentRequest,
28205             GrouperClientWs.mostRecentRequest.contains(">123<"));
28206         assertFalse(GrouperClientWs.mostRecentRequest,
28207             GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
28208         assertFalse(GrouperClientWs.mostRecentRequest,
28209             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
28210         assertTrue(GrouperClientWs.mostRecentRequest,
28211             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
28212         assertTrue(GrouperClientWs.mostRecentRequest,
28213             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
28214         assertTrue(GrouperClientWs.mostRecentRequest,
28215             GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
28216         assertTrue(GrouperClientWs.mostRecentRequest,
28217             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
28218 
28219 
28220 
28221         // ######################################################
28222         // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups
28223 
28224         baos = new ByteArrayOutputStream();
28225         System.setOut(new PrintStream(baos));
28226 
28227         try {
28228           GrouperClient.main(GrouperClientUtils.splitTrim(
28229               "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --assignAssignOwnerNamesOfAttributeDefNames=1" + attributeDefName.getName()
28230               ,
28231             " "));
28232 
28233           System.out.flush();
28234           output = new String(baos.toByteArray());
28235 
28236           System.setOut(systemOut);
28237 
28238           outputLines = GrouperClientUtils.splitTrim(output, "\n");
28239 
28240           // match: Index: 0: attributeAssignType: mem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
28241           // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
28242           pattern = Pattern
28243               .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
28244 
28245           assertEquals(0, GrouperUtil.length(outputLines));
28246           fail("Shouldnt get here");
28247 
28248         } catch (Exception e) {
28249           //ok
28250         } finally {
28251 
28252           System.setOut(systemOut);
28253 
28254         }
28255 
28256         assertTrue(GrouperClientWs.mostRecentRequest,
28257             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
28258         assertTrue(GrouperClientWs.mostRecentRequest,
28259             !GrouperClientWs.mostRecentRequest.contains("actions"));
28260         assertTrue(GrouperClientWs.mostRecentRequest,
28261             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
28262         assertTrue(GrouperClientWs.mostRecentRequest,
28263             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
28264         assertTrue(GrouperClientWs.mostRecentRequest,
28265             !GrouperClientWs.mostRecentRequest.contains("enabled"));
28266         assertTrue(GrouperClientWs.mostRecentRequest,
28267             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
28268         assertTrue(GrouperClientWs.mostRecentRequest,
28269             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
28270         assertTrue(GrouperClientWs.mostRecentRequest,
28271             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
28272         assertTrue(GrouperClientWs.mostRecentRequest,
28273             !GrouperClientWs.mostRecentRequest.contains("params"));
28274         assertTrue(GrouperClientWs.mostRecentRequest,
28275             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
28276         assertTrue(GrouperClientWs.mostRecentRequest,
28277             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
28278         assertFalse(GrouperClientWs.mostRecentRequest,
28279             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
28280         assertFalse(GrouperClientWs.mostRecentRequest,
28281             GrouperClientWs.mostRecentRequest.contains("<uuid>"));
28282         assertTrue(GrouperClientWs.mostRecentRequest,
28283             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
28284         assertTrue(GrouperClientWs.mostRecentRequest,
28285             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
28286         assertTrue(GrouperClientWs.mostRecentRequest,
28287             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
28288         assertTrue(GrouperClientWs.mostRecentRequest,
28289             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
28290         assertTrue(GrouperClientWs.mostRecentRequest,
28291             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
28292         assertTrue(GrouperClientWs.mostRecentRequest,
28293             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
28294         assertTrue(GrouperClientWs.mostRecentRequest,
28295             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
28296         assertFalse(GrouperClientWs.mostRecentRequest,
28297             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
28298         assertFalse(GrouperClientWs.mostRecentRequest,
28299             GrouperClientWs.mostRecentRequest.contains("theValue"));
28300         assertFalse(GrouperClientWs.mostRecentRequest,
28301             GrouperClientWs.mostRecentRequest.contains(">123<"));
28302         assertFalse(GrouperClientWs.mostRecentRequest,
28303             GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
28304         assertFalse(GrouperClientWs.mostRecentRequest,
28305             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
28306         assertTrue(GrouperClientWs.mostRecentRequest,
28307             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
28308         assertTrue(GrouperClientWs.mostRecentRequest,
28309             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
28310         assertTrue(GrouperClientWs.mostRecentRequest,
28311             GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
28312         assertTrue(GrouperClientWs.mostRecentRequest,
28313             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
28314 
28315 
28316         // ######################################################
28317         // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups
28318 
28319         baos = new ByteArrayOutputStream();
28320         System.setOut(new PrintStream(baos));
28321 
28322         GrouperClient.main(GrouperClientUtils.splitTrim(
28323             "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
28324             ,
28325           " "));
28326 
28327         System.out.flush();
28328         output = new String(baos.toByteArray());
28329 
28330         System.setOut(systemOut);
28331 
28332         outputLines = GrouperClientUtils.splitTrim(output, "\n");
28333 
28334         // match: Index: 0: attributeAssignType: mem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
28335         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
28336         pattern = Pattern
28337             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
28338 
28339         assertEquals(1, GrouperUtil.length(outputLines));
28340 
28341         outputLine = outputLines[0];
28342 
28343         matcher = pattern.matcher(outputLine);
28344 
28345         assertTrue(outputLine, matcher.matches());
28346         assertEquals(outputLine, "0", matcher.group(1));
28347         assertEquals(outputLine, "mem_asgn", matcher.group(2));
28348         assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
28349         assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
28350         assertEquals(outputLine, "assign", matcher.group(5));
28351         assertEquals(outputLine, "123", matcher.group(6));
28352         assertEquals(outputLine, "T", matcher.group(7));
28353         assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
28354 
28355         assertTrue(GrouperClientWs.mostRecentRequest,
28356             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
28357         assertTrue(GrouperClientWs.mostRecentRequest,
28358             !GrouperClientWs.mostRecentRequest.contains("actions"));
28359         assertTrue(GrouperClientWs.mostRecentRequest,
28360             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
28361         assertTrue(GrouperClientWs.mostRecentRequest,
28362             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
28363         assertTrue(GrouperClientWs.mostRecentRequest,
28364             !GrouperClientWs.mostRecentRequest.contains("enabled"));
28365         assertTrue(GrouperClientWs.mostRecentRequest,
28366             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
28367         assertTrue(GrouperClientWs.mostRecentRequest,
28368             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
28369         assertTrue(GrouperClientWs.mostRecentRequest,
28370             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
28371         assertTrue(GrouperClientWs.mostRecentRequest,
28372             !GrouperClientWs.mostRecentRequest.contains("params"));
28373         assertTrue(GrouperClientWs.mostRecentRequest,
28374             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
28375         assertTrue(GrouperClientWs.mostRecentRequest,
28376             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
28377         assertFalse(GrouperClientWs.mostRecentRequest,
28378             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
28379         assertTrue(GrouperClientWs.mostRecentRequest,
28380             GrouperClientWs.mostRecentRequest.contains("<uuid>"));
28381         assertTrue(GrouperClientWs.mostRecentRequest,
28382             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
28383         assertTrue(GrouperClientWs.mostRecentRequest,
28384             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
28385         assertTrue(GrouperClientWs.mostRecentRequest,
28386             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
28387         assertTrue(GrouperClientWs.mostRecentRequest,
28388             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
28389         assertTrue(GrouperClientWs.mostRecentRequest,
28390             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
28391         assertTrue(GrouperClientWs.mostRecentRequest,
28392             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
28393         assertTrue(GrouperClientWs.mostRecentRequest,
28394             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
28395         assertFalse(GrouperClientWs.mostRecentRequest,
28396             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
28397         assertFalse(GrouperClientWs.mostRecentRequest,
28398             GrouperClientWs.mostRecentRequest.contains("theValue"));
28399         assertFalse(GrouperClientWs.mostRecentRequest,
28400             GrouperClientWs.mostRecentRequest.contains(">123<"));
28401         assertFalse(GrouperClientWs.mostRecentRequest,
28402             GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
28403         assertFalse(GrouperClientWs.mostRecentRequest,
28404             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
28405         assertTrue(GrouperClientWs.mostRecentRequest,
28406             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
28407         assertTrue(GrouperClientWs.mostRecentRequest,
28408             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
28409         assertTrue(GrouperClientWs.mostRecentRequest,
28410             GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
28411         assertTrue(GrouperClientWs.mostRecentRequest,
28412             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
28413 
28414 
28415 
28416         // ######################################################
28417         // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups wrong name
28418 
28419         baos = new ByteArrayOutputStream();
28420         System.setOut(new PrintStream(baos));
28421 
28422         try {
28423           GrouperClient.main(GrouperClientUtils.splitTrim(
28424               "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --assignAssignOwnerUuidsOfAttributeDefNames=1" + attributeDefName.getId()
28425               ,
28426             " "));
28427 
28428           System.out.flush();
28429           output = new String(baos.toByteArray());
28430 
28431           System.setOut(systemOut);
28432 
28433           outputLines = GrouperClientUtils.splitTrim(output, "\n");
28434 
28435           // match: Index: 0: attributeAssignType: mem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
28436           // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
28437           pattern = Pattern
28438               .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
28439 
28440           assertEquals(1, GrouperUtil.length(outputLines));
28441           fail("Shouldnt get here");
28442         } catch (Exception e) {
28443           //good
28444         } finally {
28445 
28446           System.setOut(systemOut);
28447 
28448         }
28449 
28450         assertTrue(GrouperClientWs.mostRecentRequest,
28451             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
28452         assertTrue(GrouperClientWs.mostRecentRequest,
28453             !GrouperClientWs.mostRecentRequest.contains("actions"));
28454         assertTrue(GrouperClientWs.mostRecentRequest,
28455             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
28456         assertTrue(GrouperClientWs.mostRecentRequest,
28457             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
28458         assertTrue(GrouperClientWs.mostRecentRequest,
28459             !GrouperClientWs.mostRecentRequest.contains("enabled"));
28460         assertTrue(GrouperClientWs.mostRecentRequest,
28461             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
28462         assertTrue(GrouperClientWs.mostRecentRequest,
28463             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
28464         assertTrue(GrouperClientWs.mostRecentRequest,
28465             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
28466         assertTrue(GrouperClientWs.mostRecentRequest,
28467             !GrouperClientWs.mostRecentRequest.contains("params"));
28468         assertTrue(GrouperClientWs.mostRecentRequest,
28469             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
28470         assertTrue(GrouperClientWs.mostRecentRequest,
28471             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
28472         assertFalse(GrouperClientWs.mostRecentRequest,
28473             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
28474         assertTrue(GrouperClientWs.mostRecentRequest,
28475             GrouperClientWs.mostRecentRequest.contains("<uuid>"));
28476         assertTrue(GrouperClientWs.mostRecentRequest,
28477             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
28478         assertTrue(GrouperClientWs.mostRecentRequest,
28479             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
28480         assertTrue(GrouperClientWs.mostRecentRequest,
28481             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
28482         assertTrue(GrouperClientWs.mostRecentRequest,
28483             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
28484         assertTrue(GrouperClientWs.mostRecentRequest,
28485             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
28486         assertTrue(GrouperClientWs.mostRecentRequest,
28487             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
28488         assertTrue(GrouperClientWs.mostRecentRequest,
28489             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
28490         assertFalse(GrouperClientWs.mostRecentRequest,
28491             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
28492         assertFalse(GrouperClientWs.mostRecentRequest,
28493             GrouperClientWs.mostRecentRequest.contains("theValue"));
28494         assertFalse(GrouperClientWs.mostRecentRequest,
28495             GrouperClientWs.mostRecentRequest.contains(">123<"));
28496         assertFalse(GrouperClientWs.mostRecentRequest,
28497             GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
28498         assertFalse(GrouperClientWs.mostRecentRequest,
28499             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
28500         assertTrue(GrouperClientWs.mostRecentRequest,
28501             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
28502         assertTrue(GrouperClientWs.mostRecentRequest,
28503             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
28504         assertTrue(GrouperClientWs.mostRecentRequest,
28505             GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
28506         assertTrue(GrouperClientWs.mostRecentRequest,
28507             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
28508 
28509 
28510         // ######################################################
28511         // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups
28512 
28513         baos = new ByteArrayOutputStream();
28514         System.setOut(new PrintStream(baos));
28515 
28516         GrouperClient.main(GrouperClientUtils.splitTrim(
28517             "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
28518             + " --assignAssignOwnerActions=assign",
28519           " "));
28520 
28521         System.out.flush();
28522         output = new String(baos.toByteArray());
28523 
28524         System.setOut(systemOut);
28525 
28526         outputLines = GrouperClientUtils.splitTrim(output, "\n");
28527 
28528         // match: Index: 0: attributeAssignType: mem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
28529         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
28530         pattern = Pattern
28531             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
28532 
28533         assertEquals(1, GrouperUtil.length(outputLines));
28534 
28535         outputLine = outputLines[0];
28536 
28537         matcher = pattern.matcher(outputLine);
28538 
28539         assertTrue(outputLine, matcher.matches());
28540         assertEquals(outputLine, "0", matcher.group(1));
28541         assertEquals(outputLine, "mem_asgn", matcher.group(2));
28542         assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
28543         assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
28544         assertEquals(outputLine, "assign", matcher.group(5));
28545         assertEquals(outputLine, "123", matcher.group(6));
28546         assertEquals(outputLine, "T", matcher.group(7));
28547         assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
28548 
28549         assertTrue(GrouperClientWs.mostRecentRequest,
28550             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
28551         assertTrue(GrouperClientWs.mostRecentRequest,
28552             !GrouperClientWs.mostRecentRequest.contains("<actions>"));
28553         assertTrue(GrouperClientWs.mostRecentRequest,
28554             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
28555         assertTrue(GrouperClientWs.mostRecentRequest,
28556             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
28557         assertTrue(GrouperClientWs.mostRecentRequest,
28558             !GrouperClientWs.mostRecentRequest.contains("enabled"));
28559         assertTrue(GrouperClientWs.mostRecentRequest,
28560             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
28561         assertTrue(GrouperClientWs.mostRecentRequest,
28562             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
28563         assertTrue(GrouperClientWs.mostRecentRequest,
28564             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
28565         assertTrue(GrouperClientWs.mostRecentRequest,
28566             !GrouperClientWs.mostRecentRequest.contains("params"));
28567         assertTrue(GrouperClientWs.mostRecentRequest,
28568             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
28569         assertTrue(GrouperClientWs.mostRecentRequest,
28570             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
28571         assertFalse(GrouperClientWs.mostRecentRequest,
28572             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
28573         assertTrue(GrouperClientWs.mostRecentRequest,
28574             GrouperClientWs.mostRecentRequest.contains("<uuid>"));
28575         assertTrue(GrouperClientWs.mostRecentRequest,
28576             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
28577         assertTrue(GrouperClientWs.mostRecentRequest,
28578             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
28579         assertTrue(GrouperClientWs.mostRecentRequest,
28580             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
28581         assertTrue(GrouperClientWs.mostRecentRequest,
28582             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
28583         assertTrue(GrouperClientWs.mostRecentRequest,
28584             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
28585         assertTrue(GrouperClientWs.mostRecentRequest,
28586             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
28587         assertTrue(GrouperClientWs.mostRecentRequest,
28588             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
28589         assertFalse(GrouperClientWs.mostRecentRequest,
28590             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
28591         assertFalse(GrouperClientWs.mostRecentRequest,
28592             GrouperClientWs.mostRecentRequest.contains("theValue"));
28593         assertFalse(GrouperClientWs.mostRecentRequest,
28594             GrouperClientWs.mostRecentRequest.contains(">123<"));
28595         assertFalse(GrouperClientWs.mostRecentRequest,
28596             GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
28597         assertFalse(GrouperClientWs.mostRecentRequest,
28598             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
28599         assertTrue(GrouperClientWs.mostRecentRequest,
28600             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
28601         assertTrue(GrouperClientWs.mostRecentRequest,
28602             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
28603         assertTrue(GrouperClientWs.mostRecentRequest,
28604             GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
28605         assertTrue(GrouperClientWs.mostRecentRequest,
28606             GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
28607 
28608 
28609         // ######################################################
28610         // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups wrong action
28611 
28612         baos = new ByteArrayOutputStream();
28613         System.setOut(new PrintStream(baos));
28614 
28615         GrouperClient.main(GrouperClientUtils.splitTrim(
28616             "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
28617             + " --assignAssignOwnerActions=assign2",
28618           " "));
28619 
28620         System.out.flush();
28621         output = new String(baos.toByteArray());
28622 
28623         System.setOut(systemOut);
28624 
28625         outputLines = GrouperClientUtils.splitTrim(output, "\n");
28626 
28627         // match: Index: 0: attributeAssignType: mem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
28628         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
28629         pattern = Pattern
28630             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
28631 
28632         assertEquals(0, GrouperUtil.length(outputLines));
28633 
28634         assertTrue(GrouperClientWs.mostRecentRequest,
28635             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
28636         assertTrue(GrouperClientWs.mostRecentRequest,
28637             !GrouperClientWs.mostRecentRequest.contains("<actions>"));
28638         assertTrue(GrouperClientWs.mostRecentRequest,
28639             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
28640         assertTrue(GrouperClientWs.mostRecentRequest,
28641             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
28642         assertTrue(GrouperClientWs.mostRecentRequest,
28643             !GrouperClientWs.mostRecentRequest.contains("enabled"));
28644         assertTrue(GrouperClientWs.mostRecentRequest,
28645             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
28646         assertTrue(GrouperClientWs.mostRecentRequest,
28647             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
28648         assertTrue(GrouperClientWs.mostRecentRequest,
28649             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
28650         assertTrue(GrouperClientWs.mostRecentRequest,
28651             !GrouperClientWs.mostRecentRequest.contains("params"));
28652         assertTrue(GrouperClientWs.mostRecentRequest,
28653             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
28654         assertTrue(GrouperClientWs.mostRecentRequest,
28655             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
28656         assertFalse(GrouperClientWs.mostRecentRequest,
28657             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
28658         assertTrue(GrouperClientWs.mostRecentRequest,
28659             GrouperClientWs.mostRecentRequest.contains("<uuid>"));
28660         assertTrue(GrouperClientWs.mostRecentRequest,
28661             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
28662         assertTrue(GrouperClientWs.mostRecentRequest,
28663             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
28664         assertTrue(GrouperClientWs.mostRecentRequest,
28665             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
28666         assertTrue(GrouperClientWs.mostRecentRequest,
28667             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
28668         assertTrue(GrouperClientWs.mostRecentRequest,
28669             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
28670         assertTrue(GrouperClientWs.mostRecentRequest,
28671             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
28672         assertTrue(GrouperClientWs.mostRecentRequest,
28673             !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
28674         assertFalse(GrouperClientWs.mostRecentRequest,
28675             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
28676         assertFalse(GrouperClientWs.mostRecentRequest,
28677             GrouperClientWs.mostRecentRequest.contains("theValue"));
28678         assertFalse(GrouperClientWs.mostRecentRequest,
28679             GrouperClientWs.mostRecentRequest.contains(">123<"));
28680         assertFalse(GrouperClientWs.mostRecentRequest,
28681             GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
28682         assertFalse(GrouperClientWs.mostRecentRequest,
28683             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
28684         assertTrue(GrouperClientWs.mostRecentRequest,
28685             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
28686         assertTrue(GrouperClientWs.mostRecentRequest,
28687             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
28688         assertTrue(GrouperClientWs.mostRecentRequest,
28689             GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
28690         assertTrue(GrouperClientWs.mostRecentRequest,
28691             GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
28692 
28693 
28694 
28695         // ######################################################
28696         // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups
28697 
28698         baos = new ByteArrayOutputStream();
28699         System.setOut(new PrintStream(baos));
28700 
28701         GrouperClient.main(GrouperClientUtils.splitTrim(
28702             "--operation=getAttributeAssignmentsWs --attributeAssignType=mem_asgn --owner0SubjectId=" + SubjectTestHelper.SUBJ0_ID
28703             ,
28704           " "));
28705 
28706         System.out.flush();
28707         output = new String(baos.toByteArray());
28708 
28709         System.setOut(systemOut);
28710 
28711         outputLines = GrouperClientUtils.splitTrim(output, "\n");
28712 
28713         // match: Index: 0: attributeAssignType: mem_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
28714         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
28715         pattern = Pattern
28716             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
28717 
28718         assertEquals(1, GrouperUtil.length(outputLines));
28719 
28720         outputLine = outputLines[0];
28721 
28722         matcher = pattern.matcher(outputLine);
28723 
28724         assertTrue(outputLine, matcher.matches());
28725         assertEquals(outputLine, "0", matcher.group(1));
28726         assertEquals(outputLine, "mem_asgn", matcher.group(2));
28727         assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
28728         assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
28729         assertEquals(outputLine, "assign", matcher.group(5));
28730         assertEquals(outputLine, "123", matcher.group(6));
28731         assertEquals(outputLine, "T", matcher.group(7));
28732         assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
28733 
28734         assertTrue(GrouperClientWs.mostRecentRequest,
28735             !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
28736         assertTrue(GrouperClientWs.mostRecentRequest,
28737             !GrouperClientWs.mostRecentRequest.contains("<actions>"));
28738         assertTrue(GrouperClientWs.mostRecentRequest,
28739             GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
28740         assertTrue(GrouperClientWs.mostRecentRequest,
28741             !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
28742         assertTrue(GrouperClientWs.mostRecentRequest,
28743             !GrouperClientWs.mostRecentRequest.contains("enabled"));
28744         assertTrue(GrouperClientWs.mostRecentRequest,
28745             !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
28746         assertTrue(GrouperClientWs.mostRecentRequest,
28747             !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
28748         assertTrue(GrouperClientWs.mostRecentRequest,
28749             !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
28750         assertTrue(GrouperClientWs.mostRecentRequest,
28751             !GrouperClientWs.mostRecentRequest.contains("params"));
28752         assertTrue(GrouperClientWs.mostRecentRequest,
28753             !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
28754         assertTrue(GrouperClientWs.mostRecentRequest,
28755             !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
28756         assertFalse(GrouperClientWs.mostRecentRequest,
28757             GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
28758         assertFalse(GrouperClientWs.mostRecentRequest,
28759             GrouperClientWs.mostRecentRequest.contains("<uuid>"));
28760         assertTrue(GrouperClientWs.mostRecentRequest,
28761             !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
28762         assertTrue(GrouperClientWs.mostRecentRequest,
28763             !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
28764         assertTrue(GrouperClientWs.mostRecentRequest,
28765             !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
28766         assertTrue(GrouperClientWs.mostRecentRequest,
28767             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
28768         assertTrue(GrouperClientWs.mostRecentRequest,
28769             !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
28770         assertTrue(GrouperClientWs.mostRecentRequest,
28771             !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
28772         assertTrue(GrouperClientWs.mostRecentRequest,
28773             GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
28774         assertFalse(GrouperClientWs.mostRecentRequest,
28775             GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
28776         assertFalse(GrouperClientWs.mostRecentRequest,
28777             GrouperClientWs.mostRecentRequest.contains("theValue"));
28778         assertFalse(GrouperClientWs.mostRecentRequest,
28779             GrouperClientWs.mostRecentRequest.contains(">123<"));
28780         assertFalse(GrouperClientWs.mostRecentRequest,
28781             GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
28782         assertFalse(GrouperClientWs.mostRecentRequest,
28783             GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
28784         assertTrue(GrouperClientWs.mostRecentRequest,
28785             !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
28786         assertTrue(GrouperClientWs.mostRecentRequest,
28787             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
28788         assertTrue(GrouperClientWs.mostRecentRequest,
28789             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
28790         assertTrue(GrouperClientWs.mostRecentRequest,
28791             !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
28792 
28793 
28794       } finally {
28795         System.setOut(systemOut);
28796       }
28797 
28798     }
28799 
28800 /**
28801    * @throws Exception
28802    */
28803   public void testGetAttributeAssignsAttributeDefExtraFeatures() throws Exception {
28804 
28805     AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
28806     AttributeDefName attributeDefName2 = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignAssignName");
28807 
28808     final AttributeDef attributeDef = attributeDefName.getAttributeDef();
28809 
28810     attributeDef.setValueType(AttributeDefValueType.string);
28811     attributeDef.setAssignToAttributeDef(true);
28812     attributeDef.store();
28813 
28814     final AttributeDef attributeDef2 = attributeDefName2.getAttributeDef();
28815 
28816     attributeDef2.setAssignToGroup(false);
28817     attributeDef2.setAssignToAttributeDefAssn(true);
28818     attributeDef2.setValueType(AttributeDefValueType.integer);
28819     attributeDef2.store();
28820 
28821     AttributeDef ownerAttributeDef = new AttributeDefSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
28822       .assignName("test:attributeDefTestAttrAssign").assignCreateParentStemsIfNotExist(true)
28823       .assignDescription("description").save();
28824 
28825     //test subject 0 can read the assignment on assignment
28826     attributeDef2.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ0, AttributeDefPrivilege.ATTR_READ, false);
28827 
28828     AttributeAssignResult attributeAssignResult = ownerAttributeDef.getAttributeDelegate().assignAttribute(attributeDefName);
28829     AttributeAssign attributeAssign = attributeAssignResult.getAttributeAssign();
28830     attributeAssign.getValueDelegate().assignValue("abc");
28831 
28832     AttributeAssignResult attributeAssignResult2 = attributeAssign.getAttributeDelegate().assignAttribute(attributeDefName2);
28833     AttributeAssign attributeAssign2 = attributeAssignResult2.getAttributeAssign();
28834     attributeAssign2.getValueDelegate().assignValue("123");
28835 
28836     PrintStream systemOut = System.out;
28837 
28838     ByteArrayOutputStream baos = new ByteArrayOutputStream();
28839     System.setOut(new PrintStream(baos));
28840 
28841     try {
28842 
28843       GrouperClient.main(GrouperClientUtils.splitTrim(
28844           "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def " +
28845           "--attributeDefNames=test:testAttributeAssignDefNameDef " +
28846           "--attributeDefValueType=string --value=abc",
28847           " "));
28848       System.out.flush();
28849       String output = new String(baos.toByteArray());
28850 
28851       System.setOut(systemOut);
28852 
28853       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
28854 
28855       // match: Index: 0: attributeAssignType: attributeDef, owner: test:attributeDefTestAttrAssign, attributeDefNameName test:testAttributeAssignDefName, action: assign, values: 15,5,5, enable: T, id: a9c83eeb78c04ae5befcea36272d318c
28856       // match: ^Index: (\d+)\: attributeDef\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
28857       Pattern pattern = Pattern
28858           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
28859 
28860       assertEquals(1, GrouperUtil.length(outputLines));
28861       String outputLine = outputLines[0];
28862 
28863       Matcher matcher = pattern.matcher(outputLines[0]);
28864 
28865       assertTrue(outputLine, matcher.matches());
28866       assertEquals(outputLine, "0", matcher.group(1));
28867       assertEquals(outputLine, "attr_def", matcher.group(2));
28868       assertEquals(outputLine, "test:attributeDefTestAttrAssign", matcher.group(3));
28869       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
28870       assertEquals(outputLine, "assign", matcher.group(5));
28871       assertEquals(outputLine, "abc", matcher.group(6));
28872       assertEquals(outputLine, "T", matcher.group(7));
28873       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
28874 
28875       assertTrue(GrouperClientWs.mostRecentRequest,
28876           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
28877       assertTrue(GrouperClientWs.mostRecentRequest,
28878           !GrouperClientWs.mostRecentRequest.contains("actions"));
28879       assertTrue(GrouperClientWs.mostRecentRequest,
28880           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
28881       assertTrue(GrouperClientWs.mostRecentRequest,
28882           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
28883       assertTrue(GrouperClientWs.mostRecentRequest,
28884           !GrouperClientWs.mostRecentRequest.contains("enabled"));
28885       assertTrue(GrouperClientWs.mostRecentRequest,
28886           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
28887       assertTrue(GrouperClientWs.mostRecentRequest,
28888           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
28889       assertTrue(GrouperClientWs.mostRecentRequest,
28890           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
28891       assertTrue(GrouperClientWs.mostRecentRequest,
28892           !GrouperClientWs.mostRecentRequest.contains("params"));
28893       assertTrue(GrouperClientWs.mostRecentRequest,
28894           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
28895       assertTrue(GrouperClientWs.mostRecentRequest,
28896           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
28897       assertTrue(GrouperClientWs.mostRecentRequest,
28898           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
28899       assertTrue(GrouperClientWs.mostRecentRequest,
28900           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
28901       assertTrue(GrouperClientWs.mostRecentRequest,
28902           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
28903       assertTrue(GrouperClientWs.mostRecentRequest,
28904           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
28905       assertTrue(GrouperClientWs.mostRecentRequest,
28906           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
28907       assertTrue(GrouperClientWs.mostRecentRequest,
28908           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
28909       assertTrue(GrouperClientWs.mostRecentRequest,
28910           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
28911       assertTrue(GrouperClientWs.mostRecentRequest,
28912           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
28913       assertTrue(GrouperClientWs.mostRecentRequest,
28914           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
28915       assertTrue(GrouperClientWs.mostRecentRequest,
28916           GrouperClientWs.mostRecentRequest.contains("theValue"));
28917       assertTrue(GrouperClientWs.mostRecentRequest,
28918           GrouperClientWs.mostRecentRequest.contains("abc"));
28919       assertTrue(GrouperClientWs.mostRecentRequest,
28920           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
28921       assertTrue(GrouperClientWs.mostRecentRequest,
28922           !GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
28923       assertTrue(GrouperClientWs.mostRecentRequest,
28924           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
28925       assertTrue(GrouperClientWs.mostRecentRequest,
28926           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
28927       assertTrue(GrouperClientWs.mostRecentRequest,
28928           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
28929       assertTrue(GrouperClientWs.mostRecentRequest,
28930           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
28931       assertTrue(GrouperClientWs.mostRecentRequest,
28932           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
28933       assertTrue(GrouperClientWs.mostRecentRequest,
28934           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
28935 
28936       // ######################################################
28937       // Try wrong value
28938 
28939       baos = new ByteArrayOutputStream();
28940       System.setOut(new PrintStream(baos));
28941 
28942       GrouperClient.main(GrouperClientUtils.splitTrim(
28943           "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def --attributeDefUuids=" + attributeDef.getId() +
28944           " --attributeDefNames=test:testAttributeAssignDefNameDef " +
28945           "--attributeDefValueType=string --value=123",
28946           " "));
28947 
28948 
28949       System.out.flush();
28950       output = new String(baos.toByteArray());
28951 
28952       System.setOut(systemOut);
28953 
28954       outputLines = GrouperClientUtils.splitTrim(output, "\n");
28955 
28956       assertEquals(0, GrouperUtil.length(outputLines));
28957 //      outputLine = outputLines[0];
28958 //
28959 //      matcher = pattern.matcher(outputLines[0]);
28960 
28961       assertTrue(GrouperClientWs.mostRecentRequest,
28962           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
28963       assertTrue(GrouperClientWs.mostRecentRequest,
28964           !GrouperClientWs.mostRecentRequest.contains("actions"));
28965       assertTrue(GrouperClientWs.mostRecentRequest,
28966           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
28967       assertTrue(GrouperClientWs.mostRecentRequest,
28968           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
28969       assertTrue(GrouperClientWs.mostRecentRequest,
28970           !GrouperClientWs.mostRecentRequest.contains("enabled"));
28971       assertTrue(GrouperClientWs.mostRecentRequest,
28972           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
28973       assertTrue(GrouperClientWs.mostRecentRequest,
28974           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
28975       assertTrue(GrouperClientWs.mostRecentRequest,
28976           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
28977       assertTrue(GrouperClientWs.mostRecentRequest,
28978           !GrouperClientWs.mostRecentRequest.contains("params"));
28979       assertTrue(GrouperClientWs.mostRecentRequest,
28980           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
28981       assertTrue(GrouperClientWs.mostRecentRequest,
28982           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
28983       assertTrue(GrouperClientWs.mostRecentRequest,
28984           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
28985       assertTrue(GrouperClientWs.mostRecentRequest,
28986           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
28987       assertTrue(GrouperClientWs.mostRecentRequest,
28988           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
28989       assertTrue(GrouperClientWs.mostRecentRequest,
28990           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
28991       assertTrue(GrouperClientWs.mostRecentRequest,
28992           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
28993       assertTrue(GrouperClientWs.mostRecentRequest,
28994           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
28995       assertTrue(GrouperClientWs.mostRecentRequest,
28996           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
28997       assertTrue(GrouperClientWs.mostRecentRequest,
28998           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
28999       assertTrue(GrouperClientWs.mostRecentRequest,
29000           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
29001       assertTrue(GrouperClientWs.mostRecentRequest,
29002           GrouperClientWs.mostRecentRequest.contains("theValue"));
29003       assertTrue(GrouperClientWs.mostRecentRequest,
29004           GrouperClientWs.mostRecentRequest.contains(">123<"));
29005       assertTrue(GrouperClientWs.mostRecentRequest,
29006           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
29007       assertTrue(GrouperClientWs.mostRecentRequest,
29008           !GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
29009       assertTrue(GrouperClientWs.mostRecentRequest,
29010           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
29011       assertTrue(GrouperClientWs.mostRecentRequest,
29012           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
29013       assertTrue(GrouperClientWs.mostRecentRequest,
29014           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
29015       assertTrue(GrouperClientWs.mostRecentRequest,
29016           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
29017       assertTrue(GrouperClientWs.mostRecentRequest,
29018           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
29019       assertTrue(GrouperClientWs.mostRecentRequest,
29020           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
29021 
29022 
29023       // ######################################################
29024       // Try wrong id
29025 
29026       baos = new ByteArrayOutputStream();
29027       System.setOut(new PrintStream(baos));
29028 
29029       try {
29030         GrouperClient.main(GrouperClientUtils.splitTrim(
29031             " --operation=getAttributeAssignmentsWs --attributeAssignType=attr_def --attributeDefUuids=123" + attributeDef.getId() +
29032             " --attributeDefNames=test:testAttributeAssignDefNameDef " +
29033             "--attributeDefValueType=string --value=123",
29034             " "));
29035         fail("Shouldnt get here");
29036       } catch (GcWebServiceError gwse) {
29037         //ignore
29038       }
29039 
29040       // ######################################################
29041       // Try correct attributeDefType
29042 
29043       baos = new ByteArrayOutputStream();
29044       System.setOut(new PrintStream(baos));
29045 
29046       GrouperClient.main(GrouperClientUtils.splitTrim(
29047           "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def --attributeDefUuids=" + attributeDef.getId() +
29048           " --attributeDefValueType=string --value=abc --attributeDefType=attr",
29049           " "));
29050 
29051 
29052       System.out.flush();
29053       output = new String(baos.toByteArray());
29054 
29055       System.setOut(systemOut);
29056 
29057       outputLines = GrouperClientUtils.splitTrim(output, "\n");
29058 
29059       // match: Index: 0: attributeAssignType: attributeDef, owner: test:attributeDefTestAttrAssign, attributeDefNameName test:testAttributeAssignDefName, action: assign, values: 15,5,5, enable: T, id: a9c83eeb78c04ae5befcea36272d318c
29060       // match: ^Index: (\d+)\: attributeDef\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
29061       pattern = Pattern
29062           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
29063 
29064       assertEquals(1, GrouperUtil.length(outputLines));
29065       outputLine = outputLines[0];
29066 
29067       matcher = pattern.matcher(outputLines[0]);
29068 
29069       assertTrue(outputLine, matcher.matches());
29070       assertEquals(outputLine, "0", matcher.group(1));
29071       assertEquals(outputLine, "attr_def", matcher.group(2));
29072       assertEquals(outputLine, "test:attributeDefTestAttrAssign", matcher.group(3));
29073       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
29074       assertEquals(outputLine, "assign", matcher.group(5));
29075       assertEquals(outputLine, "abc", matcher.group(6));
29076       assertEquals(outputLine, "T", matcher.group(7));
29077       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
29078 
29079       assertTrue(GrouperClientWs.mostRecentRequest,
29080           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
29081       assertTrue(GrouperClientWs.mostRecentRequest,
29082           !GrouperClientWs.mostRecentRequest.contains("actions"));
29083       assertTrue(GrouperClientWs.mostRecentRequest,
29084           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
29085       assertTrue(GrouperClientWs.mostRecentRequest,
29086           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
29087       assertTrue(GrouperClientWs.mostRecentRequest,
29088           !GrouperClientWs.mostRecentRequest.contains("enabled"));
29089       assertTrue(GrouperClientWs.mostRecentRequest,
29090           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
29091       assertTrue(GrouperClientWs.mostRecentRequest,
29092           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
29093       assertTrue(GrouperClientWs.mostRecentRequest,
29094           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
29095       assertTrue(GrouperClientWs.mostRecentRequest,
29096           !GrouperClientWs.mostRecentRequest.contains("params"));
29097       assertTrue(GrouperClientWs.mostRecentRequest,
29098           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
29099       assertTrue(GrouperClientWs.mostRecentRequest,
29100           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
29101       assertTrue(GrouperClientWs.mostRecentRequest,
29102           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
29103       assertTrue(GrouperClientWs.mostRecentRequest,
29104           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
29105       assertTrue(GrouperClientWs.mostRecentRequest,
29106           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
29107       assertTrue(GrouperClientWs.mostRecentRequest,
29108           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
29109       assertTrue(GrouperClientWs.mostRecentRequest,
29110           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
29111       assertTrue(GrouperClientWs.mostRecentRequest,
29112           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
29113       assertTrue(GrouperClientWs.mostRecentRequest,
29114           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
29115       assertTrue(GrouperClientWs.mostRecentRequest,
29116           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
29117       assertTrue(GrouperClientWs.mostRecentRequest,
29118           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
29119       assertTrue(GrouperClientWs.mostRecentRequest,
29120           GrouperClientWs.mostRecentRequest.contains("theValue"));
29121       assertTrue(GrouperClientWs.mostRecentRequest,
29122           GrouperClientWs.mostRecentRequest.contains("abc"));
29123       assertTrue(GrouperClientWs.mostRecentRequest,
29124           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
29125       assertTrue(GrouperClientWs.mostRecentRequest,
29126           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
29127       assertTrue(GrouperClientWs.mostRecentRequest,
29128           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
29129       assertTrue(GrouperClientWs.mostRecentRequest,
29130           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
29131       assertTrue(GrouperClientWs.mostRecentRequest,
29132           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
29133       assertTrue(GrouperClientWs.mostRecentRequest,
29134           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
29135       assertTrue(GrouperClientWs.mostRecentRequest,
29136           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
29137       assertTrue(GrouperClientWs.mostRecentRequest,
29138           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
29139 
29140       // ######################################################
29141       // Try wrong attributeDefType
29142 
29143       baos = new ByteArrayOutputStream();
29144       System.setOut(new PrintStream(baos));
29145 
29146       GrouperClient.main(GrouperClientUtils.splitTrim(
29147           "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def --attributeDefUuids=" + attributeDef.getId() +
29148           " --attributeDefValueType=string --value=abc --attributeDefType=limit",
29149           " "));
29150 
29151       System.out.flush();
29152       output = new String(baos.toByteArray());
29153 
29154       System.setOut(systemOut);
29155 
29156       outputLines = GrouperClientUtils.splitTrim(output, "\n");
29157 
29158       // match: Index: 0: attributeAssignType: attributeDef, owner: test:attributeDefTestAttrAssign, attributeDefNameName test:testAttributeAssignDefName, action: assign, values: 15,5,5, enable: T, id: a9c83eeb78c04ae5befcea36272d318c
29159       // match: ^Index: (\d+)\: attributeDef\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
29160       pattern = Pattern
29161           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
29162 
29163       assertEquals(0, GrouperUtil.length(outputLines));
29164 
29165       assertTrue(GrouperClientWs.mostRecentRequest,
29166           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
29167       assertTrue(GrouperClientWs.mostRecentRequest,
29168           !GrouperClientWs.mostRecentRequest.contains("actions"));
29169       assertTrue(GrouperClientWs.mostRecentRequest,
29170           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
29171       assertTrue(GrouperClientWs.mostRecentRequest,
29172           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
29173       assertTrue(GrouperClientWs.mostRecentRequest,
29174           !GrouperClientWs.mostRecentRequest.contains("enabled"));
29175       assertTrue(GrouperClientWs.mostRecentRequest,
29176           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
29177       assertTrue(GrouperClientWs.mostRecentRequest,
29178           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
29179       assertTrue(GrouperClientWs.mostRecentRequest,
29180           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
29181       assertTrue(GrouperClientWs.mostRecentRequest,
29182           !GrouperClientWs.mostRecentRequest.contains("params"));
29183       assertTrue(GrouperClientWs.mostRecentRequest,
29184           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
29185       assertTrue(GrouperClientWs.mostRecentRequest,
29186           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
29187       assertTrue(GrouperClientWs.mostRecentRequest,
29188           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
29189       assertTrue(GrouperClientWs.mostRecentRequest,
29190           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
29191       assertTrue(GrouperClientWs.mostRecentRequest,
29192           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
29193       assertTrue(GrouperClientWs.mostRecentRequest,
29194           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
29195       assertTrue(GrouperClientWs.mostRecentRequest,
29196           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
29197       assertTrue(GrouperClientWs.mostRecentRequest,
29198           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
29199       assertTrue(GrouperClientWs.mostRecentRequest,
29200           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
29201       assertTrue(GrouperClientWs.mostRecentRequest,
29202           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
29203       assertTrue(GrouperClientWs.mostRecentRequest,
29204           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
29205       assertTrue(GrouperClientWs.mostRecentRequest,
29206           GrouperClientWs.mostRecentRequest.contains("theValue"));
29207       assertTrue(GrouperClientWs.mostRecentRequest,
29208           GrouperClientWs.mostRecentRequest.contains("abc"));
29209       assertTrue(GrouperClientWs.mostRecentRequest,
29210           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
29211       assertTrue(GrouperClientWs.mostRecentRequest,
29212           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
29213       assertTrue(GrouperClientWs.mostRecentRequest,
29214           GrouperClientWs.mostRecentRequest.contains("limit"));
29215       assertTrue(GrouperClientWs.mostRecentRequest,
29216           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
29217       assertTrue(GrouperClientWs.mostRecentRequest,
29218           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
29219       assertTrue(GrouperClientWs.mostRecentRequest,
29220           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
29221       assertTrue(GrouperClientWs.mostRecentRequest,
29222           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
29223       assertTrue(GrouperClientWs.mostRecentRequest,
29224           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
29225       assertTrue(GrouperClientWs.mostRecentRequest,
29226           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
29227 
29228       // ######################################################
29229       // Try attributeDef assignment on assignment by attributeDef
29230 
29231       baos = new ByteArrayOutputStream();
29232       System.setOut(new PrintStream(baos));
29233 
29234       GrouperClient.main(GrouperClientUtils.splitTrim(
29235           "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --attributeDefUuids=" + attributeDef2.getId(),
29236           " "));
29237 
29238       System.out.flush();
29239       output = new String(baos.toByteArray());
29240 
29241       System.setOut(systemOut);
29242 
29243       outputLines = GrouperClientUtils.splitTrim(output, "\n");
29244 
29245       // match: Index: 0: attributeAssignType: attributeDef_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
29246       // match: ^Index: (\d+)\: attributeDef\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
29247       pattern = Pattern
29248           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
29249 
29250       assertEquals(1, GrouperUtil.length(outputLines));
29251       outputLine = outputLines[0];
29252 
29253       matcher = pattern.matcher(outputLines[0]);
29254 
29255       assertTrue(outputLine, matcher.matches());
29256       assertEquals(outputLine, "0", matcher.group(1));
29257       assertEquals(outputLine, "attr_def_asgn", matcher.group(2));
29258       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
29259       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
29260       assertEquals(outputLine, "assign", matcher.group(5));
29261       assertEquals(outputLine, "123", matcher.group(6));
29262       assertEquals(outputLine, "T", matcher.group(7));
29263       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
29264 
29265       assertTrue(GrouperClientWs.mostRecentRequest,
29266           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
29267       assertTrue(GrouperClientWs.mostRecentRequest,
29268           !GrouperClientWs.mostRecentRequest.contains("actions"));
29269       assertTrue(GrouperClientWs.mostRecentRequest,
29270           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
29271       assertTrue(GrouperClientWs.mostRecentRequest,
29272           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
29273       assertTrue(GrouperClientWs.mostRecentRequest,
29274           !GrouperClientWs.mostRecentRequest.contains("enabled"));
29275       assertTrue(GrouperClientWs.mostRecentRequest,
29276           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
29277       assertTrue(GrouperClientWs.mostRecentRequest,
29278           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
29279       assertTrue(GrouperClientWs.mostRecentRequest,
29280           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
29281       assertTrue(GrouperClientWs.mostRecentRequest,
29282           !GrouperClientWs.mostRecentRequest.contains("params"));
29283       assertTrue(GrouperClientWs.mostRecentRequest,
29284           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
29285       assertTrue(GrouperClientWs.mostRecentRequest,
29286           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
29287       assertTrue(GrouperClientWs.mostRecentRequest,
29288           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
29289       assertTrue(GrouperClientWs.mostRecentRequest,
29290           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
29291       assertTrue(GrouperClientWs.mostRecentRequest,
29292           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
29293       assertTrue(GrouperClientWs.mostRecentRequest,
29294           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
29295       assertTrue(GrouperClientWs.mostRecentRequest,
29296           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
29297       assertTrue(GrouperClientWs.mostRecentRequest,
29298           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
29299       assertTrue(GrouperClientWs.mostRecentRequest,
29300           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
29301       assertTrue(GrouperClientWs.mostRecentRequest,
29302           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
29303       assertFalse(GrouperClientWs.mostRecentRequest,
29304           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
29305       assertFalse(GrouperClientWs.mostRecentRequest,
29306           GrouperClientWs.mostRecentRequest.contains("theValue"));
29307       assertFalse(GrouperClientWs.mostRecentRequest,
29308           GrouperClientWs.mostRecentRequest.contains(">abc<"));
29309       assertTrue(GrouperClientWs.mostRecentRequest,
29310           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
29311       assertFalse(GrouperClientWs.mostRecentRequest,
29312           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
29313       assertTrue(GrouperClientWs.mostRecentRequest,
29314           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
29315       assertTrue(GrouperClientWs.mostRecentRequest,
29316           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
29317       assertTrue(GrouperClientWs.mostRecentRequest,
29318           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
29319       assertTrue(GrouperClientWs.mostRecentRequest,
29320           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
29321       assertTrue(GrouperClientWs.mostRecentRequest,
29322           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
29323       assertTrue(GrouperClientWs.mostRecentRequest,
29324           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
29325 
29326       // ######################################################
29327       // Try attributeDef assignment on assignment by attributeDef with wrong id
29328 
29329       baos = new ByteArrayOutputStream();
29330       System.setOut(new PrintStream(baos));
29331 
29332       try {
29333         GrouperClient.main(GrouperClientUtils.splitTrim(
29334             "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --attributeDefUuids=1" + attributeDef2.getId(),
29335             " "));
29336 
29337         System.out.flush();
29338         output = new String(baos.toByteArray());
29339 
29340         System.setOut(systemOut);
29341 
29342         outputLines = GrouperClientUtils.splitTrim(output, "\n");
29343 
29344         // match: Index: 0: attributeAssignType: attributeDef_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
29345         // match: ^Index: (\d+)\: attributeDef\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
29346         pattern = Pattern
29347             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
29348 
29349         assertEquals(0, GrouperUtil.length(outputLines));
29350         fail("Why did it not fail?");
29351       } catch (Exception e) {
29352         //good
29353       }
29354       assertTrue(GrouperClientWs.mostRecentRequest,
29355           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
29356       assertTrue(GrouperClientWs.mostRecentRequest,
29357           !GrouperClientWs.mostRecentRequest.contains("actions"));
29358       assertTrue(GrouperClientWs.mostRecentRequest,
29359           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
29360       assertTrue(GrouperClientWs.mostRecentRequest,
29361           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
29362       assertTrue(GrouperClientWs.mostRecentRequest,
29363           !GrouperClientWs.mostRecentRequest.contains("enabled"));
29364       assertTrue(GrouperClientWs.mostRecentRequest,
29365           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
29366       assertTrue(GrouperClientWs.mostRecentRequest,
29367           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
29368       assertTrue(GrouperClientWs.mostRecentRequest,
29369           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
29370       assertTrue(GrouperClientWs.mostRecentRequest,
29371           !GrouperClientWs.mostRecentRequest.contains("params"));
29372       assertTrue(GrouperClientWs.mostRecentRequest,
29373           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
29374       assertTrue(GrouperClientWs.mostRecentRequest,
29375           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
29376       assertTrue(GrouperClientWs.mostRecentRequest,
29377           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
29378       assertTrue(GrouperClientWs.mostRecentRequest,
29379           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
29380       assertTrue(GrouperClientWs.mostRecentRequest,
29381           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
29382       assertTrue(GrouperClientWs.mostRecentRequest,
29383           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
29384       assertTrue(GrouperClientWs.mostRecentRequest,
29385           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
29386       assertTrue(GrouperClientWs.mostRecentRequest,
29387           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
29388       assertTrue(GrouperClientWs.mostRecentRequest,
29389           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
29390       assertTrue(GrouperClientWs.mostRecentRequest,
29391           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
29392       assertFalse(GrouperClientWs.mostRecentRequest,
29393           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
29394       assertFalse(GrouperClientWs.mostRecentRequest,
29395           GrouperClientWs.mostRecentRequest.contains("theValue"));
29396       assertFalse(GrouperClientWs.mostRecentRequest,
29397           GrouperClientWs.mostRecentRequest.contains("abc"));
29398       assertTrue(GrouperClientWs.mostRecentRequest,
29399           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
29400       assertFalse(GrouperClientWs.mostRecentRequest,
29401           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
29402       assertTrue(GrouperClientWs.mostRecentRequest,
29403           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
29404       assertTrue(GrouperClientWs.mostRecentRequest,
29405           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
29406       assertTrue(GrouperClientWs.mostRecentRequest,
29407           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
29408       assertTrue(GrouperClientWs.mostRecentRequest,
29409           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
29410       assertTrue(GrouperClientWs.mostRecentRequest,
29411           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
29412       assertTrue(GrouperClientWs.mostRecentRequest,
29413           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
29414 
29415 
29416       // ######################################################
29417       // Try attributeDef assignment on assignment by attributeDef and value
29418 
29419       baos = new ByteArrayOutputStream();
29420       System.setOut(new PrintStream(baos));
29421 
29422       GrouperClient.main(GrouperClientUtils.splitTrim(
29423           "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --attributeDefUuids=" + attributeDef2.getId()
29424           + " --attributeDefValueType=integer --value=123 ",
29425         " "));
29426 
29427       System.out.flush();
29428       output = new String(baos.toByteArray());
29429 
29430       System.setOut(systemOut);
29431 
29432       outputLines = GrouperClientUtils.splitTrim(output, "\n");
29433 
29434       // match: Index: 0: attributeAssignType: attributeDef_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
29435       // match: ^Index: (\d+)\: attributeDef\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
29436       pattern = Pattern
29437           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
29438 
29439       assertEquals(1, GrouperUtil.length(outputLines));
29440       outputLine = outputLines[0];
29441 
29442       matcher = pattern.matcher(outputLines[0]);
29443 
29444       assertTrue(outputLine, matcher.matches());
29445       assertEquals(outputLine, "0", matcher.group(1));
29446       assertEquals(outputLine, "attr_def_asgn", matcher.group(2));
29447       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
29448       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
29449       assertEquals(outputLine, "assign", matcher.group(5));
29450       assertEquals(outputLine, "123", matcher.group(6));
29451       assertEquals(outputLine, "T", matcher.group(7));
29452       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
29453 
29454       assertTrue(GrouperClientWs.mostRecentRequest,
29455           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
29456       assertTrue(GrouperClientWs.mostRecentRequest,
29457           !GrouperClientWs.mostRecentRequest.contains("actions"));
29458       assertTrue(GrouperClientWs.mostRecentRequest,
29459           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
29460       assertTrue(GrouperClientWs.mostRecentRequest,
29461           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
29462       assertTrue(GrouperClientWs.mostRecentRequest,
29463           !GrouperClientWs.mostRecentRequest.contains("enabled"));
29464       assertTrue(GrouperClientWs.mostRecentRequest,
29465           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
29466       assertTrue(GrouperClientWs.mostRecentRequest,
29467           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
29468       assertTrue(GrouperClientWs.mostRecentRequest,
29469           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
29470       assertTrue(GrouperClientWs.mostRecentRequest,
29471           !GrouperClientWs.mostRecentRequest.contains("params"));
29472       assertTrue(GrouperClientWs.mostRecentRequest,
29473           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
29474       assertTrue(GrouperClientWs.mostRecentRequest,
29475           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
29476       assertTrue(GrouperClientWs.mostRecentRequest,
29477           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
29478       assertTrue(GrouperClientWs.mostRecentRequest,
29479           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
29480       assertTrue(GrouperClientWs.mostRecentRequest,
29481           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
29482       assertTrue(GrouperClientWs.mostRecentRequest,
29483           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
29484       assertTrue(GrouperClientWs.mostRecentRequest,
29485           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
29486       assertTrue(GrouperClientWs.mostRecentRequest,
29487           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
29488       assertTrue(GrouperClientWs.mostRecentRequest,
29489           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
29490       assertTrue(GrouperClientWs.mostRecentRequest,
29491           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
29492       assertTrue(GrouperClientWs.mostRecentRequest,
29493           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
29494       assertTrue(GrouperClientWs.mostRecentRequest,
29495           GrouperClientWs.mostRecentRequest.contains("theValue"));
29496       assertTrue(GrouperClientWs.mostRecentRequest,
29497           GrouperClientWs.mostRecentRequest.contains(">123<"));
29498       assertTrue(GrouperClientWs.mostRecentRequest,
29499           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
29500       assertFalse(GrouperClientWs.mostRecentRequest,
29501           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
29502       assertTrue(GrouperClientWs.mostRecentRequest,
29503           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
29504       assertTrue(GrouperClientWs.mostRecentRequest,
29505           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
29506       assertTrue(GrouperClientWs.mostRecentRequest,
29507           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
29508       assertTrue(GrouperClientWs.mostRecentRequest,
29509           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
29510       assertTrue(GrouperClientWs.mostRecentRequest,
29511           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
29512       assertTrue(GrouperClientWs.mostRecentRequest,
29513           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
29514 
29515 
29516       // ######################################################
29517       // Try attributeDef assignment on assignment by attributeDef and wrong value
29518 
29519       baos = new ByteArrayOutputStream();
29520       System.setOut(new PrintStream(baos));
29521 
29522       GrouperClient.main(GrouperClientUtils.splitTrim(
29523           "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --attributeDefUuids=" + attributeDef2.getId()
29524           + " --attributeDefValueType=integer --value=1234 ",
29525         " "));
29526 
29527       System.out.flush();
29528       output = new String(baos.toByteArray());
29529 
29530       System.setOut(systemOut);
29531 
29532       outputLines = GrouperClientUtils.splitTrim(output, "\n");
29533 
29534       // match: Index: 0: attributeAssignType: attributeDef_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
29535       // match: ^Index: (\d+)\: attributeDef\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
29536       pattern = Pattern
29537           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
29538 
29539       assertEquals(0, GrouperUtil.length(outputLines));
29540 
29541       assertTrue(GrouperClientWs.mostRecentRequest,
29542           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
29543       assertTrue(GrouperClientWs.mostRecentRequest,
29544           !GrouperClientWs.mostRecentRequest.contains("actions"));
29545       assertTrue(GrouperClientWs.mostRecentRequest,
29546           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
29547       assertTrue(GrouperClientWs.mostRecentRequest,
29548           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
29549       assertTrue(GrouperClientWs.mostRecentRequest,
29550           !GrouperClientWs.mostRecentRequest.contains("enabled"));
29551       assertTrue(GrouperClientWs.mostRecentRequest,
29552           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
29553       assertTrue(GrouperClientWs.mostRecentRequest,
29554           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
29555       assertTrue(GrouperClientWs.mostRecentRequest,
29556           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
29557       assertTrue(GrouperClientWs.mostRecentRequest,
29558           !GrouperClientWs.mostRecentRequest.contains("params"));
29559       assertTrue(GrouperClientWs.mostRecentRequest,
29560           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
29561       assertTrue(GrouperClientWs.mostRecentRequest,
29562           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
29563       assertTrue(GrouperClientWs.mostRecentRequest,
29564           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
29565       assertTrue(GrouperClientWs.mostRecentRequest,
29566           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
29567       assertTrue(GrouperClientWs.mostRecentRequest,
29568           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
29569       assertTrue(GrouperClientWs.mostRecentRequest,
29570           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
29571       assertTrue(GrouperClientWs.mostRecentRequest,
29572           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
29573       assertTrue(GrouperClientWs.mostRecentRequest,
29574           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
29575       assertTrue(GrouperClientWs.mostRecentRequest,
29576           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
29577       assertTrue(GrouperClientWs.mostRecentRequest,
29578           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
29579       assertTrue(GrouperClientWs.mostRecentRequest,
29580           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
29581       assertTrue(GrouperClientWs.mostRecentRequest,
29582           GrouperClientWs.mostRecentRequest.contains("theValue"));
29583       assertTrue(GrouperClientWs.mostRecentRequest,
29584           GrouperClientWs.mostRecentRequest.contains("1234"));
29585       assertTrue(GrouperClientWs.mostRecentRequest,
29586           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
29587       assertFalse(GrouperClientWs.mostRecentRequest,
29588           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
29589       assertTrue(GrouperClientWs.mostRecentRequest,
29590           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
29591       assertTrue(GrouperClientWs.mostRecentRequest,
29592           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
29593       assertTrue(GrouperClientWs.mostRecentRequest,
29594           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
29595       assertTrue(GrouperClientWs.mostRecentRequest,
29596           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
29597       assertTrue(GrouperClientWs.mostRecentRequest,
29598           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
29599       assertTrue(GrouperClientWs.mostRecentRequest,
29600           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
29601 
29602 
29603       // ######################################################
29604       // Try attributeDef assignment on assignment by attributeDef and value
29605 
29606       baos = new ByteArrayOutputStream();
29607       System.setOut(new PrintStream(baos));
29608 
29609       GrouperClient.main(GrouperClientUtils.splitTrim(
29610           "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --attributeDefUuids=" + attributeDef2.getId()
29611           + " --includeAssignmentsFromAssignments=T ",
29612         " "));
29613 
29614       System.out.flush();
29615       output = new String(baos.toByteArray());
29616 
29617       System.setOut(systemOut);
29618 
29619       outputLines = GrouperClientUtils.splitTrim(output, "\n");
29620 
29621       // match: Index: 0: attributeAssignType: attributeDef_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
29622       // match: ^Index: (\d+)\: attributeDef\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
29623       pattern = Pattern
29624           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
29625 
29626       assertEquals(2, GrouperUtil.length(outputLines));
29627       outputLine = outputLines[0];
29628 
29629       matcher = pattern.matcher(outputLine);
29630 
29631       assertTrue(outputLine, matcher.matches());
29632       assertEquals(outputLine, "0", matcher.group(1));
29633       assertEquals(outputLine, "attr_def", matcher.group(2));
29634       assertEquals(outputLine, "test:attributeDefTestAttrAssign", matcher.group(3));
29635       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
29636       assertEquals(outputLine, "assign", matcher.group(5));
29637       assertEquals(outputLine, "abc", matcher.group(6));
29638       assertEquals(outputLine, "T", matcher.group(7));
29639       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
29640 
29641       outputLine = outputLines[1];
29642 
29643       matcher = pattern.matcher(outputLine);
29644 
29645       assertTrue(outputLine, matcher.matches());
29646       assertEquals(outputLine, "1", matcher.group(1));
29647       assertEquals(outputLine, "attr_def_asgn", matcher.group(2));
29648       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
29649       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
29650       assertEquals(outputLine, "assign", matcher.group(5));
29651       assertEquals(outputLine, "123", matcher.group(6));
29652       assertEquals(outputLine, "T", matcher.group(7));
29653       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
29654 
29655       assertTrue(GrouperClientWs.mostRecentRequest,
29656           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
29657       assertTrue(GrouperClientWs.mostRecentRequest,
29658           !GrouperClientWs.mostRecentRequest.contains("actions"));
29659       assertTrue(GrouperClientWs.mostRecentRequest,
29660           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
29661       assertTrue(GrouperClientWs.mostRecentRequest,
29662           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
29663       assertTrue(GrouperClientWs.mostRecentRequest,
29664           !GrouperClientWs.mostRecentRequest.contains("enabled"));
29665       assertTrue(GrouperClientWs.mostRecentRequest,
29666           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
29667       assertTrue(GrouperClientWs.mostRecentRequest,
29668           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
29669       assertTrue(GrouperClientWs.mostRecentRequest,
29670           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
29671       assertTrue(GrouperClientWs.mostRecentRequest,
29672           !GrouperClientWs.mostRecentRequest.contains("params"));
29673       assertTrue(GrouperClientWs.mostRecentRequest,
29674           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
29675       assertTrue(GrouperClientWs.mostRecentRequest,
29676           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
29677       assertTrue(GrouperClientWs.mostRecentRequest,
29678           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
29679       assertTrue(GrouperClientWs.mostRecentRequest,
29680           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
29681       assertTrue(GrouperClientWs.mostRecentRequest,
29682           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
29683       assertTrue(GrouperClientWs.mostRecentRequest,
29684           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
29685       assertTrue(GrouperClientWs.mostRecentRequest,
29686           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
29687       assertTrue(GrouperClientWs.mostRecentRequest,
29688           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
29689       assertTrue(GrouperClientWs.mostRecentRequest,
29690           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
29691       assertTrue(GrouperClientWs.mostRecentRequest,
29692           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
29693       assertFalse(GrouperClientWs.mostRecentRequest,
29694           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
29695       assertFalse(GrouperClientWs.mostRecentRequest,
29696           GrouperClientWs.mostRecentRequest.contains("theValue"));
29697       assertFalse(GrouperClientWs.mostRecentRequest,
29698           GrouperClientWs.mostRecentRequest.contains(">123<"));
29699       assertTrue(GrouperClientWs.mostRecentRequest,
29700           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
29701       assertFalse(GrouperClientWs.mostRecentRequest,
29702           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
29703       assertTrue(GrouperClientWs.mostRecentRequest,
29704           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
29705       assertTrue(GrouperClientWs.mostRecentRequest,
29706           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
29707       assertTrue(GrouperClientWs.mostRecentRequest,
29708           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
29709       assertTrue(GrouperClientWs.mostRecentRequest,
29710           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
29711       assertTrue(GrouperClientWs.mostRecentRequest,
29712           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
29713       assertTrue(GrouperClientWs.mostRecentRequest,
29714           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
29715 
29716 
29717       // ######################################################
29718       // Try attributeDef assignment on assignment by owner attribute assign id with wrong id
29719 
29720       baos = new ByteArrayOutputStream();
29721       System.setOut(new PrintStream(baos));
29722 
29723       try {
29724         GrouperClient.main(GrouperClientUtils.splitTrim(
29725             "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --assignAssignOwnerAttributeAssignUuids=1" + attributeAssign.getId()
29726             ,
29727           " "));
29728 
29729         System.out.flush();
29730         output = new String(baos.toByteArray());
29731 
29732         System.setOut(systemOut);
29733 
29734         outputLines = GrouperClientUtils.splitTrim(output, "\n");
29735 
29736         // match: Index: 0: attributeAssignType: attributeDef_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
29737         // match: ^Index: (\d+)\: attributeDef\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
29738         pattern = Pattern
29739             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
29740 
29741         assertEquals(0, GrouperUtil.length(outputLines));
29742         fail("Shouldnt get here");
29743       } catch (Exception e) {
29744         //good
29745       } finally {
29746         System.setOut(systemOut);
29747 
29748       }
29749 
29750       assertTrue(GrouperClientWs.mostRecentRequest,
29751           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
29752       assertTrue(GrouperClientWs.mostRecentRequest,
29753           !GrouperClientWs.mostRecentRequest.contains("actions"));
29754       assertTrue(GrouperClientWs.mostRecentRequest,
29755           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
29756       assertTrue(GrouperClientWs.mostRecentRequest,
29757           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
29758       assertTrue(GrouperClientWs.mostRecentRequest,
29759           !GrouperClientWs.mostRecentRequest.contains("enabled"));
29760       assertTrue(GrouperClientWs.mostRecentRequest,
29761           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
29762       assertTrue(GrouperClientWs.mostRecentRequest,
29763           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
29764       assertTrue(GrouperClientWs.mostRecentRequest,
29765           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
29766       assertTrue(GrouperClientWs.mostRecentRequest,
29767           !GrouperClientWs.mostRecentRequest.contains("params"));
29768       assertTrue(GrouperClientWs.mostRecentRequest,
29769           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
29770       assertTrue(GrouperClientWs.mostRecentRequest,
29771           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
29772       assertFalse(GrouperClientWs.mostRecentRequest,
29773           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
29774       assertTrue(GrouperClientWs.mostRecentRequest,
29775           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
29776       assertTrue(GrouperClientWs.mostRecentRequest,
29777           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
29778       assertTrue(GrouperClientWs.mostRecentRequest,
29779           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
29780       assertTrue(GrouperClientWs.mostRecentRequest,
29781           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
29782       assertTrue(GrouperClientWs.mostRecentRequest,
29783           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
29784       assertTrue(GrouperClientWs.mostRecentRequest,
29785           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
29786       assertTrue(GrouperClientWs.mostRecentRequest,
29787           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
29788       assertTrue(GrouperClientWs.mostRecentRequest,
29789           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
29790       assertFalse(GrouperClientWs.mostRecentRequest,
29791           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
29792       assertFalse(GrouperClientWs.mostRecentRequest,
29793           GrouperClientWs.mostRecentRequest.contains("theValue"));
29794       assertFalse(GrouperClientWs.mostRecentRequest,
29795           GrouperClientWs.mostRecentRequest.contains(">123<"));
29796       assertFalse(GrouperClientWs.mostRecentRequest,
29797           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
29798       assertFalse(GrouperClientWs.mostRecentRequest,
29799           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
29800       assertTrue(GrouperClientWs.mostRecentRequest,
29801           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
29802       assertTrue(GrouperClientWs.mostRecentRequest,
29803           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
29804       assertTrue(GrouperClientWs.mostRecentRequest,
29805           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
29806       assertTrue(GrouperClientWs.mostRecentRequest,
29807           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
29808       assertTrue(GrouperClientWs.mostRecentRequest,
29809           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
29810       assertTrue(GrouperClientWs.mostRecentRequest,
29811           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
29812 
29813       // ######################################################
29814       // Try attributeDef assignment on assignment by owner attribute assign id
29815 
29816       baos = new ByteArrayOutputStream();
29817       System.setOut(new PrintStream(baos));
29818 
29819       GrouperClient.main(GrouperClientUtils.splitTrim(
29820           "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --assignAssignOwnerAttributeAssignUuids=" + attributeAssign.getId()
29821           ,
29822         " "));
29823 
29824       System.out.flush();
29825       output = new String(baos.toByteArray());
29826 
29827       System.setOut(systemOut);
29828 
29829       outputLines = GrouperClientUtils.splitTrim(output, "\n");
29830 
29831       // match: Index: 0: attributeAssignType: attributeDef_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
29832       // match: ^Index: (\d+)\: attributeDef\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
29833       pattern = Pattern
29834           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
29835 
29836       assertEquals(1, GrouperUtil.length(outputLines));
29837 
29838       outputLine = outputLines[0];
29839 
29840       matcher = pattern.matcher(outputLine);
29841 
29842       assertTrue(outputLine, matcher.matches());
29843       assertEquals(outputLine, "0", matcher.group(1));
29844       assertEquals(outputLine, "attr_def_asgn", matcher.group(2));
29845       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
29846       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
29847       assertEquals(outputLine, "assign", matcher.group(5));
29848       assertEquals(outputLine, "123", matcher.group(6));
29849       assertEquals(outputLine, "T", matcher.group(7));
29850       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
29851 
29852       assertTrue(GrouperClientWs.mostRecentRequest,
29853           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
29854       assertTrue(GrouperClientWs.mostRecentRequest,
29855           !GrouperClientWs.mostRecentRequest.contains("actions"));
29856       assertTrue(GrouperClientWs.mostRecentRequest,
29857           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
29858       assertTrue(GrouperClientWs.mostRecentRequest,
29859           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
29860       assertTrue(GrouperClientWs.mostRecentRequest,
29861           !GrouperClientWs.mostRecentRequest.contains("enabled"));
29862       assertTrue(GrouperClientWs.mostRecentRequest,
29863           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
29864       assertTrue(GrouperClientWs.mostRecentRequest,
29865           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
29866       assertTrue(GrouperClientWs.mostRecentRequest,
29867           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
29868       assertTrue(GrouperClientWs.mostRecentRequest,
29869           !GrouperClientWs.mostRecentRequest.contains("params"));
29870       assertTrue(GrouperClientWs.mostRecentRequest,
29871           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
29872       assertTrue(GrouperClientWs.mostRecentRequest,
29873           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
29874       assertFalse(GrouperClientWs.mostRecentRequest,
29875           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
29876       assertTrue(GrouperClientWs.mostRecentRequest,
29877           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
29878       assertTrue(GrouperClientWs.mostRecentRequest,
29879           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
29880       assertTrue(GrouperClientWs.mostRecentRequest,
29881           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
29882       assertTrue(GrouperClientWs.mostRecentRequest,
29883           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
29884       assertTrue(GrouperClientWs.mostRecentRequest,
29885           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
29886       assertTrue(GrouperClientWs.mostRecentRequest,
29887           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
29888       assertTrue(GrouperClientWs.mostRecentRequest,
29889           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
29890       assertTrue(GrouperClientWs.mostRecentRequest,
29891           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
29892       assertFalse(GrouperClientWs.mostRecentRequest,
29893           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
29894       assertFalse(GrouperClientWs.mostRecentRequest,
29895           GrouperClientWs.mostRecentRequest.contains("theValue"));
29896       assertFalse(GrouperClientWs.mostRecentRequest,
29897           GrouperClientWs.mostRecentRequest.contains(">123<"));
29898       assertFalse(GrouperClientWs.mostRecentRequest,
29899           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
29900       assertFalse(GrouperClientWs.mostRecentRequest,
29901           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
29902       assertTrue(GrouperClientWs.mostRecentRequest,
29903           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
29904       assertTrue(GrouperClientWs.mostRecentRequest,
29905           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
29906       assertTrue(GrouperClientWs.mostRecentRequest,
29907           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
29908       assertTrue(GrouperClientWs.mostRecentRequest,
29909           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
29910       assertTrue(GrouperClientWs.mostRecentRequest,
29911           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
29912       assertTrue(GrouperClientWs.mostRecentRequest,
29913           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
29914 
29915 
29916       // ######################################################
29917       // Try attributeDef assignment on assignment by wsAssignAssignOwnerAttributeDefLookups
29918 
29919       baos = new ByteArrayOutputStream();
29920       System.setOut(new PrintStream(baos));
29921 
29922       GrouperClient.main(GrouperClientUtils.splitTrim(
29923           "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --assignAssignOwnerNamesOfAttributeDefs=" + attributeDef.getName()
29924           ,
29925         " "));
29926 
29927       System.out.flush();
29928       output = new String(baos.toByteArray());
29929 
29930       System.setOut(systemOut);
29931 
29932       outputLines = GrouperClientUtils.splitTrim(output, "\n");
29933 
29934       // match: Index: 0: attributeAssignType: attributeDef_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
29935       // match: ^Index: (\d+)\: attributeDef\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
29936       pattern = Pattern
29937           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
29938 
29939       assertEquals(1, GrouperUtil.length(outputLines));
29940 
29941       outputLine = outputLines[0];
29942 
29943       matcher = pattern.matcher(outputLine);
29944 
29945       assertTrue(outputLine, matcher.matches());
29946       assertEquals(outputLine, "0", matcher.group(1));
29947       assertEquals(outputLine, "attr_def_asgn", matcher.group(2));
29948       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
29949       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
29950       assertEquals(outputLine, "assign", matcher.group(5));
29951       assertEquals(outputLine, "123", matcher.group(6));
29952       assertEquals(outputLine, "T", matcher.group(7));
29953       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
29954 
29955       assertTrue(GrouperClientWs.mostRecentRequest,
29956           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
29957       assertTrue(GrouperClientWs.mostRecentRequest,
29958           !GrouperClientWs.mostRecentRequest.contains("actions"));
29959       assertTrue(GrouperClientWs.mostRecentRequest,
29960           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
29961       assertTrue(GrouperClientWs.mostRecentRequest,
29962           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
29963       assertTrue(GrouperClientWs.mostRecentRequest,
29964           !GrouperClientWs.mostRecentRequest.contains("enabled"));
29965       assertTrue(GrouperClientWs.mostRecentRequest,
29966           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
29967       assertTrue(GrouperClientWs.mostRecentRequest,
29968           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
29969       assertTrue(GrouperClientWs.mostRecentRequest,
29970           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
29971       assertTrue(GrouperClientWs.mostRecentRequest,
29972           !GrouperClientWs.mostRecentRequest.contains("params"));
29973       assertTrue(GrouperClientWs.mostRecentRequest,
29974           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
29975       assertTrue(GrouperClientWs.mostRecentRequest,
29976           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
29977       assertFalse(GrouperClientWs.mostRecentRequest,
29978           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
29979       assertFalse(GrouperClientWs.mostRecentRequest,
29980           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
29981       assertTrue(GrouperClientWs.mostRecentRequest,
29982           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
29983       assertTrue(GrouperClientWs.mostRecentRequest,
29984           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
29985       assertTrue(GrouperClientWs.mostRecentRequest,
29986           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
29987       assertTrue(GrouperClientWs.mostRecentRequest,
29988           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
29989       assertTrue(GrouperClientWs.mostRecentRequest,
29990           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
29991       assertTrue(GrouperClientWs.mostRecentRequest,
29992           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
29993       assertTrue(GrouperClientWs.mostRecentRequest,
29994           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
29995       assertFalse(GrouperClientWs.mostRecentRequest,
29996           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
29997       assertFalse(GrouperClientWs.mostRecentRequest,
29998           GrouperClientWs.mostRecentRequest.contains("theValue"));
29999       assertFalse(GrouperClientWs.mostRecentRequest,
30000           GrouperClientWs.mostRecentRequest.contains(">123<"));
30001       assertFalse(GrouperClientWs.mostRecentRequest,
30002           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
30003       assertFalse(GrouperClientWs.mostRecentRequest,
30004           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
30005       assertTrue(GrouperClientWs.mostRecentRequest,
30006           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
30007       assertTrue(GrouperClientWs.mostRecentRequest,
30008           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
30009       assertTrue(GrouperClientWs.mostRecentRequest,
30010           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
30011       assertTrue(GrouperClientWs.mostRecentRequest,
30012           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
30013       assertTrue(GrouperClientWs.mostRecentRequest,
30014           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
30015       assertTrue(GrouperClientWs.mostRecentRequest,
30016           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
30017 
30018 
30019 
30020       // ######################################################
30021       // Try attributeDef assignment on assignment by wsAssignAssignOwnerAttributeDefLookups with wrong name
30022 
30023       baos = new ByteArrayOutputStream();
30024       System.setOut(new PrintStream(baos));
30025 
30026       try {
30027         GrouperClient.main(GrouperClientUtils.splitTrim(
30028             "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --assignAssignOwnerNamesOfAttributeDefs=1" + attributeDef.getName()
30029             ,
30030           " "));
30031 
30032         System.out.flush();
30033         output = new String(baos.toByteArray());
30034 
30035         System.setOut(systemOut);
30036 
30037         outputLines = GrouperClientUtils.splitTrim(output, "\n");
30038 
30039         // match: Index: 0: attributeAssignType: attributeDef_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
30040         // match: ^Index: (\d+)\: attributeDef\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
30041         pattern = Pattern
30042             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
30043 
30044         assertEquals(0, GrouperUtil.length(outputLines));
30045 
30046         fail("shouldnt get here");
30047       } catch (Exception e) {
30048         //good
30049       } finally {
30050         System.setOut(systemOut);
30051       }
30052 
30053       assertTrue(GrouperClientWs.mostRecentRequest,
30054           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
30055       assertTrue(GrouperClientWs.mostRecentRequest,
30056           !GrouperClientWs.mostRecentRequest.contains("actions"));
30057       assertTrue(GrouperClientWs.mostRecentRequest,
30058           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
30059       assertTrue(GrouperClientWs.mostRecentRequest,
30060           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
30061       assertTrue(GrouperClientWs.mostRecentRequest,
30062           !GrouperClientWs.mostRecentRequest.contains("enabled"));
30063       assertTrue(GrouperClientWs.mostRecentRequest,
30064           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
30065       assertTrue(GrouperClientWs.mostRecentRequest,
30066           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
30067       assertTrue(GrouperClientWs.mostRecentRequest,
30068           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
30069       assertTrue(GrouperClientWs.mostRecentRequest,
30070           !GrouperClientWs.mostRecentRequest.contains("params"));
30071       assertTrue(GrouperClientWs.mostRecentRequest,
30072           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
30073       assertTrue(GrouperClientWs.mostRecentRequest,
30074           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
30075       assertFalse(GrouperClientWs.mostRecentRequest,
30076           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
30077       assertFalse(GrouperClientWs.mostRecentRequest,
30078           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
30079       assertTrue(GrouperClientWs.mostRecentRequest,
30080           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
30081       assertTrue(GrouperClientWs.mostRecentRequest,
30082           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
30083       assertTrue(GrouperClientWs.mostRecentRequest,
30084           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
30085       assertTrue(GrouperClientWs.mostRecentRequest,
30086           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
30087       assertTrue(GrouperClientWs.mostRecentRequest,
30088           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
30089       assertTrue(GrouperClientWs.mostRecentRequest,
30090           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
30091       assertTrue(GrouperClientWs.mostRecentRequest,
30092           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
30093       assertFalse(GrouperClientWs.mostRecentRequest,
30094           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
30095       assertFalse(GrouperClientWs.mostRecentRequest,
30096           GrouperClientWs.mostRecentRequest.contains("theValue"));
30097       assertFalse(GrouperClientWs.mostRecentRequest,
30098           GrouperClientWs.mostRecentRequest.contains(">123<"));
30099       assertFalse(GrouperClientWs.mostRecentRequest,
30100           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
30101       assertFalse(GrouperClientWs.mostRecentRequest,
30102           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
30103       assertTrue(GrouperClientWs.mostRecentRequest,
30104           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
30105       assertTrue(GrouperClientWs.mostRecentRequest,
30106           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
30107       assertTrue(GrouperClientWs.mostRecentRequest,
30108           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
30109       assertTrue(GrouperClientWs.mostRecentRequest,
30110           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
30111       assertTrue(GrouperClientWs.mostRecentRequest,
30112           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
30113       assertTrue(GrouperClientWs.mostRecentRequest,
30114           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
30115 
30116 
30117       // ######################################################
30118       // Try attributeDef assignment on assignment by wsAssignAssignOwnerAttributeDefLookups
30119 
30120       baos = new ByteArrayOutputStream();
30121       System.setOut(new PrintStream(baos));
30122 
30123       GrouperClient.main(GrouperClientUtils.splitTrim(
30124           "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --assignAssignOwnerUuidsOfAttributeDefs=" + attributeDef.getId()
30125           ,
30126         " "));
30127 
30128       System.out.flush();
30129       output = new String(baos.toByteArray());
30130 
30131       System.setOut(systemOut);
30132 
30133       outputLines = GrouperClientUtils.splitTrim(output, "\n");
30134 
30135       // match: Index: 0: attributeAssignType: attributeDef_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
30136       // match: ^Index: (\d+)\: attributeDef\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
30137       pattern = Pattern
30138           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
30139 
30140       assertEquals(1, GrouperUtil.length(outputLines));
30141 
30142       outputLine = outputLines[0];
30143 
30144       matcher = pattern.matcher(outputLine);
30145 
30146       assertTrue(outputLine, matcher.matches());
30147       assertEquals(outputLine, "0", matcher.group(1));
30148       assertEquals(outputLine, "attr_def_asgn", matcher.group(2));
30149       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
30150       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
30151       assertEquals(outputLine, "assign", matcher.group(5));
30152       assertEquals(outputLine, "123", matcher.group(6));
30153       assertEquals(outputLine, "T", matcher.group(7));
30154       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
30155 
30156       assertTrue(GrouperClientWs.mostRecentRequest,
30157           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
30158       assertTrue(GrouperClientWs.mostRecentRequest,
30159           !GrouperClientWs.mostRecentRequest.contains("actions"));
30160       assertTrue(GrouperClientWs.mostRecentRequest,
30161           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
30162       assertTrue(GrouperClientWs.mostRecentRequest,
30163           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
30164       assertTrue(GrouperClientWs.mostRecentRequest,
30165           !GrouperClientWs.mostRecentRequest.contains("enabled"));
30166       assertTrue(GrouperClientWs.mostRecentRequest,
30167           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
30168       assertTrue(GrouperClientWs.mostRecentRequest,
30169           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
30170       assertTrue(GrouperClientWs.mostRecentRequest,
30171           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
30172       assertTrue(GrouperClientWs.mostRecentRequest,
30173           !GrouperClientWs.mostRecentRequest.contains("params"));
30174       assertTrue(GrouperClientWs.mostRecentRequest,
30175           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
30176       assertTrue(GrouperClientWs.mostRecentRequest,
30177           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
30178       assertFalse(GrouperClientWs.mostRecentRequest,
30179           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
30180       assertTrue(GrouperClientWs.mostRecentRequest,
30181           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
30182       assertTrue(GrouperClientWs.mostRecentRequest,
30183           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
30184       assertTrue(GrouperClientWs.mostRecentRequest,
30185           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
30186       assertTrue(GrouperClientWs.mostRecentRequest,
30187           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
30188       assertTrue(GrouperClientWs.mostRecentRequest,
30189           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
30190       assertTrue(GrouperClientWs.mostRecentRequest,
30191           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
30192       assertTrue(GrouperClientWs.mostRecentRequest,
30193           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
30194       assertTrue(GrouperClientWs.mostRecentRequest,
30195           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
30196       assertFalse(GrouperClientWs.mostRecentRequest,
30197           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
30198       assertFalse(GrouperClientWs.mostRecentRequest,
30199           GrouperClientWs.mostRecentRequest.contains("theValue"));
30200       assertFalse(GrouperClientWs.mostRecentRequest,
30201           GrouperClientWs.mostRecentRequest.contains(">123<"));
30202       assertFalse(GrouperClientWs.mostRecentRequest,
30203           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
30204       assertFalse(GrouperClientWs.mostRecentRequest,
30205           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
30206       assertTrue(GrouperClientWs.mostRecentRequest,
30207           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
30208       assertTrue(GrouperClientWs.mostRecentRequest,
30209           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
30210       assertTrue(GrouperClientWs.mostRecentRequest,
30211           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
30212       assertTrue(GrouperClientWs.mostRecentRequest,
30213           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
30214       assertTrue(GrouperClientWs.mostRecentRequest,
30215           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
30216       assertTrue(GrouperClientWs.mostRecentRequest,
30217           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
30218 
30219 
30220       // ######################################################
30221       // Try attributeDef assignment on assignment by wsAssignAssignOwnerAttributeDefLookups
30222 
30223       baos = new ByteArrayOutputStream();
30224       System.setOut(new PrintStream(baos));
30225 
30226       GrouperClient.main(GrouperClientUtils.splitTrim(
30227           "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --assignAssignOwnerUuidsOfAttributeDefs=" + attributeDef.getId()
30228           ,
30229         " "));
30230 
30231       System.out.flush();
30232       output = new String(baos.toByteArray());
30233 
30234       System.setOut(systemOut);
30235 
30236       outputLines = GrouperClientUtils.splitTrim(output, "\n");
30237 
30238       // match: Index: 0: attributeAssignType: attr_def_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
30239       // match: ^Index: (\d+)\: attributeDef\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
30240       pattern = Pattern
30241           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
30242 
30243       assertEquals(1, GrouperUtil.length(outputLines));
30244 
30245       outputLine = outputLines[0];
30246 
30247       matcher = pattern.matcher(outputLine);
30248 
30249       assertTrue(outputLine, matcher.matches());
30250       assertEquals(outputLine, "0", matcher.group(1));
30251       assertEquals(outputLine, "attr_def_asgn", matcher.group(2));
30252       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
30253       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
30254       assertEquals(outputLine, "assign", matcher.group(5));
30255       assertEquals(outputLine, "123", matcher.group(6));
30256       assertEquals(outputLine, "T", matcher.group(7));
30257       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
30258 
30259       assertTrue(GrouperClientWs.mostRecentRequest,
30260           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
30261       assertTrue(GrouperClientWs.mostRecentRequest,
30262           !GrouperClientWs.mostRecentRequest.contains("actions"));
30263       assertTrue(GrouperClientWs.mostRecentRequest,
30264           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
30265       assertTrue(GrouperClientWs.mostRecentRequest,
30266           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
30267       assertTrue(GrouperClientWs.mostRecentRequest,
30268           !GrouperClientWs.mostRecentRequest.contains("enabled"));
30269       assertTrue(GrouperClientWs.mostRecentRequest,
30270           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
30271       assertTrue(GrouperClientWs.mostRecentRequest,
30272           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
30273       assertTrue(GrouperClientWs.mostRecentRequest,
30274           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
30275       assertTrue(GrouperClientWs.mostRecentRequest,
30276           !GrouperClientWs.mostRecentRequest.contains("params"));
30277       assertTrue(GrouperClientWs.mostRecentRequest,
30278           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
30279       assertTrue(GrouperClientWs.mostRecentRequest,
30280           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
30281       assertFalse(GrouperClientWs.mostRecentRequest,
30282           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
30283       assertTrue(GrouperClientWs.mostRecentRequest,
30284           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
30285       assertTrue(GrouperClientWs.mostRecentRequest,
30286           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
30287       assertTrue(GrouperClientWs.mostRecentRequest,
30288           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
30289       assertTrue(GrouperClientWs.mostRecentRequest,
30290           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
30291       assertTrue(GrouperClientWs.mostRecentRequest,
30292           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
30293       assertTrue(GrouperClientWs.mostRecentRequest,
30294           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
30295       assertTrue(GrouperClientWs.mostRecentRequest,
30296           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
30297       assertTrue(GrouperClientWs.mostRecentRequest,
30298           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
30299       assertFalse(GrouperClientWs.mostRecentRequest,
30300           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
30301       assertFalse(GrouperClientWs.mostRecentRequest,
30302           GrouperClientWs.mostRecentRequest.contains("theValue"));
30303       assertFalse(GrouperClientWs.mostRecentRequest,
30304           GrouperClientWs.mostRecentRequest.contains(">123<"));
30305       assertFalse(GrouperClientWs.mostRecentRequest,
30306           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
30307       assertFalse(GrouperClientWs.mostRecentRequest,
30308           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
30309       assertTrue(GrouperClientWs.mostRecentRequest,
30310           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
30311       assertTrue(GrouperClientWs.mostRecentRequest,
30312           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
30313       assertTrue(GrouperClientWs.mostRecentRequest,
30314           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
30315       assertTrue(GrouperClientWs.mostRecentRequest,
30316           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
30317       assertTrue(GrouperClientWs.mostRecentRequest,
30318           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
30319       assertTrue(GrouperClientWs.mostRecentRequest,
30320           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
30321 
30322 
30323 
30324       // ######################################################
30325       // Try attributeDef assignment on assignment by wsAssignAssignOwnerAttributeDefLookups
30326 
30327       baos = new ByteArrayOutputStream();
30328       System.setOut(new PrintStream(baos));
30329 
30330       try {
30331         GrouperClient.main(GrouperClientUtils.splitTrim(
30332             "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --assignAssignOwnerUuidsOfAttributeDefs=1" + attributeDef.getId()
30333             ,
30334           " "));
30335 
30336         System.out.flush();
30337         output = new String(baos.toByteArray());
30338 
30339         System.setOut(systemOut);
30340 
30341         outputLines = GrouperClientUtils.splitTrim(output, "\n");
30342 
30343         // match: Index: 0: attributeAssignType: attributeDef_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
30344         // match: ^Index: (\d+)\: attributeDef\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
30345         pattern = Pattern
30346             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
30347 
30348         assertEquals(0, GrouperUtil.length(outputLines));
30349         fail("Shouldnt get here");
30350       } catch (Exception e) {
30351         //good
30352       } finally {
30353 
30354         System.setOut(systemOut);
30355 
30356       }
30357 
30358       assertTrue(GrouperClientWs.mostRecentRequest,
30359           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
30360       assertTrue(GrouperClientWs.mostRecentRequest,
30361           !GrouperClientWs.mostRecentRequest.contains("actions"));
30362       assertTrue(GrouperClientWs.mostRecentRequest,
30363           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
30364       assertTrue(GrouperClientWs.mostRecentRequest,
30365           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
30366       assertTrue(GrouperClientWs.mostRecentRequest,
30367           !GrouperClientWs.mostRecentRequest.contains("enabled"));
30368       assertTrue(GrouperClientWs.mostRecentRequest,
30369           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
30370       assertTrue(GrouperClientWs.mostRecentRequest,
30371           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
30372       assertTrue(GrouperClientWs.mostRecentRequest,
30373           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
30374       assertTrue(GrouperClientWs.mostRecentRequest,
30375           !GrouperClientWs.mostRecentRequest.contains("params"));
30376       assertTrue(GrouperClientWs.mostRecentRequest,
30377           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
30378       assertTrue(GrouperClientWs.mostRecentRequest,
30379           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
30380       assertFalse(GrouperClientWs.mostRecentRequest,
30381           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
30382       assertTrue(GrouperClientWs.mostRecentRequest,
30383           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
30384       assertTrue(GrouperClientWs.mostRecentRequest,
30385           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
30386       assertTrue(GrouperClientWs.mostRecentRequest,
30387           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
30388       assertTrue(GrouperClientWs.mostRecentRequest,
30389           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
30390       assertTrue(GrouperClientWs.mostRecentRequest,
30391           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
30392       assertTrue(GrouperClientWs.mostRecentRequest,
30393           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
30394       assertTrue(GrouperClientWs.mostRecentRequest,
30395           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
30396       assertTrue(GrouperClientWs.mostRecentRequest,
30397           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
30398       assertFalse(GrouperClientWs.mostRecentRequest,
30399           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
30400       assertFalse(GrouperClientWs.mostRecentRequest,
30401           GrouperClientWs.mostRecentRequest.contains("theValue"));
30402       assertFalse(GrouperClientWs.mostRecentRequest,
30403           GrouperClientWs.mostRecentRequest.contains(">123<"));
30404       assertFalse(GrouperClientWs.mostRecentRequest,
30405           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
30406       assertFalse(GrouperClientWs.mostRecentRequest,
30407           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
30408       assertTrue(GrouperClientWs.mostRecentRequest,
30409           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
30410       assertTrue(GrouperClientWs.mostRecentRequest,
30411           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
30412       assertTrue(GrouperClientWs.mostRecentRequest,
30413           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
30414       assertTrue(GrouperClientWs.mostRecentRequest,
30415           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
30416       assertTrue(GrouperClientWs.mostRecentRequest,
30417           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
30418       assertTrue(GrouperClientWs.mostRecentRequest,
30419           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
30420 
30421 
30422       // ######################################################
30423       // Try attributeDef assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups
30424 
30425       baos = new ByteArrayOutputStream();
30426       System.setOut(new PrintStream(baos));
30427 
30428       GrouperClient.main(GrouperClientUtils.splitTrim(
30429           "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --assignAssignOwnerNamesOfAttributeDefNames=" + attributeDefName.getName()
30430           ,
30431         " "));
30432 
30433       System.out.flush();
30434       output = new String(baos.toByteArray());
30435 
30436       System.setOut(systemOut);
30437 
30438       outputLines = GrouperClientUtils.splitTrim(output, "\n");
30439 
30440       // match: Index: 0: attributeAssignType: attributeDef_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
30441       // match: ^Index: (\d+)\: attributeDef\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
30442       pattern = Pattern
30443           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
30444 
30445       assertEquals(1, GrouperUtil.length(outputLines));
30446 
30447       outputLine = outputLines[0];
30448 
30449       matcher = pattern.matcher(outputLine);
30450 
30451       assertTrue(outputLine, matcher.matches());
30452       assertEquals(outputLine, "0", matcher.group(1));
30453       assertEquals(outputLine, "attr_def_asgn", matcher.group(2));
30454       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
30455       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
30456       assertEquals(outputLine, "assign", matcher.group(5));
30457       assertEquals(outputLine, "123", matcher.group(6));
30458       assertEquals(outputLine, "T", matcher.group(7));
30459       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
30460 
30461       assertTrue(GrouperClientWs.mostRecentRequest,
30462           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
30463       assertTrue(GrouperClientWs.mostRecentRequest,
30464           !GrouperClientWs.mostRecentRequest.contains("actions"));
30465       assertTrue(GrouperClientWs.mostRecentRequest,
30466           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
30467       assertTrue(GrouperClientWs.mostRecentRequest,
30468           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
30469       assertTrue(GrouperClientWs.mostRecentRequest,
30470           !GrouperClientWs.mostRecentRequest.contains("enabled"));
30471       assertTrue(GrouperClientWs.mostRecentRequest,
30472           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
30473       assertTrue(GrouperClientWs.mostRecentRequest,
30474           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
30475       assertTrue(GrouperClientWs.mostRecentRequest,
30476           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
30477       assertTrue(GrouperClientWs.mostRecentRequest,
30478           !GrouperClientWs.mostRecentRequest.contains("params"));
30479       assertTrue(GrouperClientWs.mostRecentRequest,
30480           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
30481       assertTrue(GrouperClientWs.mostRecentRequest,
30482           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
30483       assertFalse(GrouperClientWs.mostRecentRequest,
30484           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
30485       assertFalse(GrouperClientWs.mostRecentRequest,
30486           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
30487       assertTrue(GrouperClientWs.mostRecentRequest,
30488           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
30489       assertTrue(GrouperClientWs.mostRecentRequest,
30490           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
30491       assertTrue(GrouperClientWs.mostRecentRequest,
30492           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
30493       assertTrue(GrouperClientWs.mostRecentRequest,
30494           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
30495       assertTrue(GrouperClientWs.mostRecentRequest,
30496           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
30497       assertTrue(GrouperClientWs.mostRecentRequest,
30498           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
30499       assertTrue(GrouperClientWs.mostRecentRequest,
30500           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
30501       assertFalse(GrouperClientWs.mostRecentRequest,
30502           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
30503       assertFalse(GrouperClientWs.mostRecentRequest,
30504           GrouperClientWs.mostRecentRequest.contains("theValue"));
30505       assertFalse(GrouperClientWs.mostRecentRequest,
30506           GrouperClientWs.mostRecentRequest.contains(">123<"));
30507       assertFalse(GrouperClientWs.mostRecentRequest,
30508           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
30509       assertFalse(GrouperClientWs.mostRecentRequest,
30510           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
30511       assertTrue(GrouperClientWs.mostRecentRequest,
30512           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
30513       assertTrue(GrouperClientWs.mostRecentRequest,
30514           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
30515       assertTrue(GrouperClientWs.mostRecentRequest,
30516           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
30517       assertTrue(GrouperClientWs.mostRecentRequest,
30518           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
30519 
30520 
30521 
30522       // ######################################################
30523       // Try attributeDef assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups
30524 
30525       baos = new ByteArrayOutputStream();
30526       System.setOut(new PrintStream(baos));
30527 
30528       try {
30529         GrouperClient.main(GrouperClientUtils.splitTrim(
30530             "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --assignAssignOwnerNamesOfAttributeDefNames=1" + attributeDefName.getName()
30531             ,
30532           " "));
30533 
30534         System.out.flush();
30535         output = new String(baos.toByteArray());
30536 
30537         System.setOut(systemOut);
30538 
30539         outputLines = GrouperClientUtils.splitTrim(output, "\n");
30540 
30541         // match: Index: 0: attributeAssignType: attributeDef_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
30542         // match: ^Index: (\d+)\: attributeDef\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
30543         pattern = Pattern
30544             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
30545 
30546         assertEquals(0, GrouperUtil.length(outputLines));
30547         fail("Shouldnt get here");
30548 
30549       } catch (Exception e) {
30550         //ok
30551       } finally {
30552 
30553         System.setOut(systemOut);
30554 
30555       }
30556 
30557       assertTrue(GrouperClientWs.mostRecentRequest,
30558           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
30559       assertTrue(GrouperClientWs.mostRecentRequest,
30560           !GrouperClientWs.mostRecentRequest.contains("actions"));
30561       assertTrue(GrouperClientWs.mostRecentRequest,
30562           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
30563       assertTrue(GrouperClientWs.mostRecentRequest,
30564           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
30565       assertTrue(GrouperClientWs.mostRecentRequest,
30566           !GrouperClientWs.mostRecentRequest.contains("enabled"));
30567       assertTrue(GrouperClientWs.mostRecentRequest,
30568           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
30569       assertTrue(GrouperClientWs.mostRecentRequest,
30570           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
30571       assertTrue(GrouperClientWs.mostRecentRequest,
30572           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
30573       assertTrue(GrouperClientWs.mostRecentRequest,
30574           !GrouperClientWs.mostRecentRequest.contains("params"));
30575       assertTrue(GrouperClientWs.mostRecentRequest,
30576           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
30577       assertTrue(GrouperClientWs.mostRecentRequest,
30578           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
30579       assertFalse(GrouperClientWs.mostRecentRequest,
30580           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
30581       assertFalse(GrouperClientWs.mostRecentRequest,
30582           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
30583       assertTrue(GrouperClientWs.mostRecentRequest,
30584           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
30585       assertTrue(GrouperClientWs.mostRecentRequest,
30586           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
30587       assertTrue(GrouperClientWs.mostRecentRequest,
30588           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
30589       assertTrue(GrouperClientWs.mostRecentRequest,
30590           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
30591       assertTrue(GrouperClientWs.mostRecentRequest,
30592           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
30593       assertTrue(GrouperClientWs.mostRecentRequest,
30594           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
30595       assertTrue(GrouperClientWs.mostRecentRequest,
30596           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
30597       assertFalse(GrouperClientWs.mostRecentRequest,
30598           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
30599       assertFalse(GrouperClientWs.mostRecentRequest,
30600           GrouperClientWs.mostRecentRequest.contains("theValue"));
30601       assertFalse(GrouperClientWs.mostRecentRequest,
30602           GrouperClientWs.mostRecentRequest.contains(">123<"));
30603       assertFalse(GrouperClientWs.mostRecentRequest,
30604           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
30605       assertFalse(GrouperClientWs.mostRecentRequest,
30606           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
30607       assertTrue(GrouperClientWs.mostRecentRequest,
30608           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
30609       assertTrue(GrouperClientWs.mostRecentRequest,
30610           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
30611       assertTrue(GrouperClientWs.mostRecentRequest,
30612           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
30613       assertTrue(GrouperClientWs.mostRecentRequest,
30614           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
30615 
30616 
30617       // ######################################################
30618       // Try attributeDef assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups
30619 
30620       baos = new ByteArrayOutputStream();
30621       System.setOut(new PrintStream(baos));
30622 
30623       GrouperClient.main(GrouperClientUtils.splitTrim(
30624           "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
30625           ,
30626         " "));
30627 
30628       System.out.flush();
30629       output = new String(baos.toByteArray());
30630 
30631       System.setOut(systemOut);
30632 
30633       outputLines = GrouperClientUtils.splitTrim(output, "\n");
30634 
30635       // match: Index: 0: attributeAssignType: attr_def_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
30636       // match: ^Index: (\d+)\: attributeDef\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
30637       pattern = Pattern
30638           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
30639 
30640       assertEquals(1, GrouperUtil.length(outputLines));
30641 
30642       outputLine = outputLines[0];
30643 
30644       matcher = pattern.matcher(outputLine);
30645 
30646       assertTrue(outputLine, matcher.matches());
30647       assertEquals(outputLine, "0", matcher.group(1));
30648       assertEquals(outputLine, "attr_def_asgn", matcher.group(2));
30649       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
30650       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
30651       assertEquals(outputLine, "assign", matcher.group(5));
30652       assertEquals(outputLine, "123", matcher.group(6));
30653       assertEquals(outputLine, "T", matcher.group(7));
30654       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
30655 
30656       assertTrue(GrouperClientWs.mostRecentRequest,
30657           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
30658       assertTrue(GrouperClientWs.mostRecentRequest,
30659           !GrouperClientWs.mostRecentRequest.contains("actions"));
30660       assertTrue(GrouperClientWs.mostRecentRequest,
30661           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
30662       assertTrue(GrouperClientWs.mostRecentRequest,
30663           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
30664       assertTrue(GrouperClientWs.mostRecentRequest,
30665           !GrouperClientWs.mostRecentRequest.contains("enabled"));
30666       assertTrue(GrouperClientWs.mostRecentRequest,
30667           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
30668       assertTrue(GrouperClientWs.mostRecentRequest,
30669           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
30670       assertTrue(GrouperClientWs.mostRecentRequest,
30671           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
30672       assertTrue(GrouperClientWs.mostRecentRequest,
30673           !GrouperClientWs.mostRecentRequest.contains("params"));
30674       assertTrue(GrouperClientWs.mostRecentRequest,
30675           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
30676       assertTrue(GrouperClientWs.mostRecentRequest,
30677           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
30678       assertFalse(GrouperClientWs.mostRecentRequest,
30679           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
30680       assertTrue(GrouperClientWs.mostRecentRequest,
30681           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
30682       assertTrue(GrouperClientWs.mostRecentRequest,
30683           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
30684       assertTrue(GrouperClientWs.mostRecentRequest,
30685           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
30686       assertTrue(GrouperClientWs.mostRecentRequest,
30687           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
30688       assertTrue(GrouperClientWs.mostRecentRequest,
30689           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
30690       assertTrue(GrouperClientWs.mostRecentRequest,
30691           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
30692       assertTrue(GrouperClientWs.mostRecentRequest,
30693           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
30694       assertTrue(GrouperClientWs.mostRecentRequest,
30695           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
30696       assertFalse(GrouperClientWs.mostRecentRequest,
30697           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
30698       assertFalse(GrouperClientWs.mostRecentRequest,
30699           GrouperClientWs.mostRecentRequest.contains("theValue"));
30700       assertFalse(GrouperClientWs.mostRecentRequest,
30701           GrouperClientWs.mostRecentRequest.contains(">123<"));
30702       assertFalse(GrouperClientWs.mostRecentRequest,
30703           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
30704       assertFalse(GrouperClientWs.mostRecentRequest,
30705           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
30706       assertTrue(GrouperClientWs.mostRecentRequest,
30707           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
30708       assertTrue(GrouperClientWs.mostRecentRequest,
30709           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
30710       assertTrue(GrouperClientWs.mostRecentRequest,
30711           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
30712       assertTrue(GrouperClientWs.mostRecentRequest,
30713           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
30714 
30715 
30716 
30717       // ######################################################
30718       // Try attributeDef assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups wrong name
30719 
30720       baos = new ByteArrayOutputStream();
30721       System.setOut(new PrintStream(baos));
30722 
30723       try {
30724         GrouperClient.main(GrouperClientUtils.splitTrim(
30725             "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --assignAssignOwnerUuidsOfAttributeDefNames=1" + attributeDefName.getId()
30726             ,
30727           " "));
30728 
30729         System.out.flush();
30730         output = new String(baos.toByteArray());
30731 
30732         System.setOut(systemOut);
30733 
30734         outputLines = GrouperClientUtils.splitTrim(output, "\n");
30735 
30736         // match: Index: 0: attributeAssignType: attributeDef_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
30737         // match: ^Index: (\d+)\: attributeDef\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
30738         pattern = Pattern
30739             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
30740 
30741         assertEquals(1, GrouperUtil.length(outputLines));
30742         fail("Shouldnt get here");
30743       } catch (Exception e) {
30744         //good
30745       } finally {
30746 
30747         System.setOut(systemOut);
30748 
30749       }
30750 
30751       assertTrue(GrouperClientWs.mostRecentRequest,
30752           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
30753       assertTrue(GrouperClientWs.mostRecentRequest,
30754           !GrouperClientWs.mostRecentRequest.contains("actions"));
30755       assertTrue(GrouperClientWs.mostRecentRequest,
30756           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
30757       assertTrue(GrouperClientWs.mostRecentRequest,
30758           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
30759       assertTrue(GrouperClientWs.mostRecentRequest,
30760           !GrouperClientWs.mostRecentRequest.contains("enabled"));
30761       assertTrue(GrouperClientWs.mostRecentRequest,
30762           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
30763       assertTrue(GrouperClientWs.mostRecentRequest,
30764           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
30765       assertTrue(GrouperClientWs.mostRecentRequest,
30766           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
30767       assertTrue(GrouperClientWs.mostRecentRequest,
30768           !GrouperClientWs.mostRecentRequest.contains("params"));
30769       assertTrue(GrouperClientWs.mostRecentRequest,
30770           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
30771       assertTrue(GrouperClientWs.mostRecentRequest,
30772           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
30773       assertFalse(GrouperClientWs.mostRecentRequest,
30774           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
30775       assertTrue(GrouperClientWs.mostRecentRequest,
30776           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
30777       assertTrue(GrouperClientWs.mostRecentRequest,
30778           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
30779       assertTrue(GrouperClientWs.mostRecentRequest,
30780           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
30781       assertTrue(GrouperClientWs.mostRecentRequest,
30782           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
30783       assertTrue(GrouperClientWs.mostRecentRequest,
30784           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
30785       assertTrue(GrouperClientWs.mostRecentRequest,
30786           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
30787       assertTrue(GrouperClientWs.mostRecentRequest,
30788           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
30789       assertTrue(GrouperClientWs.mostRecentRequest,
30790           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
30791       assertFalse(GrouperClientWs.mostRecentRequest,
30792           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
30793       assertFalse(GrouperClientWs.mostRecentRequest,
30794           GrouperClientWs.mostRecentRequest.contains("theValue"));
30795       assertFalse(GrouperClientWs.mostRecentRequest,
30796           GrouperClientWs.mostRecentRequest.contains(">123<"));
30797       assertFalse(GrouperClientWs.mostRecentRequest,
30798           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
30799       assertFalse(GrouperClientWs.mostRecentRequest,
30800           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
30801       assertTrue(GrouperClientWs.mostRecentRequest,
30802           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
30803       assertTrue(GrouperClientWs.mostRecentRequest,
30804           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
30805       assertTrue(GrouperClientWs.mostRecentRequest,
30806           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
30807       assertTrue(GrouperClientWs.mostRecentRequest,
30808           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
30809 
30810 
30811       // ######################################################
30812       // Try attributeDef assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups
30813 
30814       baos = new ByteArrayOutputStream();
30815       System.setOut(new PrintStream(baos));
30816 
30817       GrouperClient.main(GrouperClientUtils.splitTrim(
30818           "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
30819           + " --assignAssignOwnerActions=assign",
30820         " "));
30821 
30822       System.out.flush();
30823       output = new String(baos.toByteArray());
30824 
30825       System.setOut(systemOut);
30826 
30827       outputLines = GrouperClientUtils.splitTrim(output, "\n");
30828 
30829       // match: Index: 0: attributeAssignType: attributeDef_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
30830       // match: ^Index: (\d+)\: attributeDef\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
30831       pattern = Pattern
30832           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
30833 
30834       assertEquals(1, GrouperUtil.length(outputLines));
30835 
30836       outputLine = outputLines[0];
30837 
30838       matcher = pattern.matcher(outputLine);
30839 
30840       assertTrue(outputLine, matcher.matches());
30841       assertEquals(outputLine, "0", matcher.group(1));
30842       assertEquals(outputLine, "attr_def_asgn", matcher.group(2));
30843       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
30844       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
30845       assertEquals(outputLine, "assign", matcher.group(5));
30846       assertEquals(outputLine, "123", matcher.group(6));
30847       assertEquals(outputLine, "T", matcher.group(7));
30848       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
30849 
30850       assertTrue(GrouperClientWs.mostRecentRequest,
30851           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
30852       assertTrue(GrouperClientWs.mostRecentRequest,
30853           !GrouperClientWs.mostRecentRequest.contains("<actions>"));
30854       assertTrue(GrouperClientWs.mostRecentRequest,
30855           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
30856       assertTrue(GrouperClientWs.mostRecentRequest,
30857           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
30858       assertTrue(GrouperClientWs.mostRecentRequest,
30859           !GrouperClientWs.mostRecentRequest.contains("enabled"));
30860       assertTrue(GrouperClientWs.mostRecentRequest,
30861           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
30862       assertTrue(GrouperClientWs.mostRecentRequest,
30863           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
30864       assertTrue(GrouperClientWs.mostRecentRequest,
30865           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
30866       assertTrue(GrouperClientWs.mostRecentRequest,
30867           !GrouperClientWs.mostRecentRequest.contains("params"));
30868       assertTrue(GrouperClientWs.mostRecentRequest,
30869           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
30870       assertTrue(GrouperClientWs.mostRecentRequest,
30871           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
30872       assertFalse(GrouperClientWs.mostRecentRequest,
30873           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
30874       assertTrue(GrouperClientWs.mostRecentRequest,
30875           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
30876       assertTrue(GrouperClientWs.mostRecentRequest,
30877           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
30878       assertTrue(GrouperClientWs.mostRecentRequest,
30879           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
30880       assertTrue(GrouperClientWs.mostRecentRequest,
30881           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
30882       assertTrue(GrouperClientWs.mostRecentRequest,
30883           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
30884       assertTrue(GrouperClientWs.mostRecentRequest,
30885           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
30886       assertTrue(GrouperClientWs.mostRecentRequest,
30887           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
30888       assertTrue(GrouperClientWs.mostRecentRequest,
30889           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
30890       assertFalse(GrouperClientWs.mostRecentRequest,
30891           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
30892       assertFalse(GrouperClientWs.mostRecentRequest,
30893           GrouperClientWs.mostRecentRequest.contains("theValue"));
30894       assertFalse(GrouperClientWs.mostRecentRequest,
30895           GrouperClientWs.mostRecentRequest.contains(">123<"));
30896       assertFalse(GrouperClientWs.mostRecentRequest,
30897           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
30898       assertFalse(GrouperClientWs.mostRecentRequest,
30899           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
30900       assertTrue(GrouperClientWs.mostRecentRequest,
30901           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
30902       assertTrue(GrouperClientWs.mostRecentRequest,
30903           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
30904       assertTrue(GrouperClientWs.mostRecentRequest,
30905           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
30906       assertTrue(GrouperClientWs.mostRecentRequest,
30907           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
30908 
30909 
30910       // ######################################################
30911       // Try attributeDef assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups wrong action
30912 
30913       baos = new ByteArrayOutputStream();
30914       System.setOut(new PrintStream(baos));
30915 
30916       GrouperClient.main(GrouperClientUtils.splitTrim(
30917           "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
30918           + " --assignAssignOwnerActions=assign2",
30919         " "));
30920 
30921       System.out.flush();
30922       output = new String(baos.toByteArray());
30923 
30924       System.setOut(systemOut);
30925 
30926       outputLines = GrouperClientUtils.splitTrim(output, "\n");
30927 
30928       // match: Index: 0: attributeAssignType: attributeDef_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
30929       // match: ^Index: (\d+)\: attributeDef\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
30930       pattern = Pattern
30931           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
30932 
30933       assertEquals(0, GrouperUtil.length(outputLines));
30934 
30935       assertTrue(GrouperClientWs.mostRecentRequest,
30936           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
30937       assertTrue(GrouperClientWs.mostRecentRequest,
30938           !GrouperClientWs.mostRecentRequest.contains("<actions>"));
30939       assertTrue(GrouperClientWs.mostRecentRequest,
30940           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
30941       assertTrue(GrouperClientWs.mostRecentRequest,
30942           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
30943       assertTrue(GrouperClientWs.mostRecentRequest,
30944           !GrouperClientWs.mostRecentRequest.contains("enabled"));
30945       assertTrue(GrouperClientWs.mostRecentRequest,
30946           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
30947       assertTrue(GrouperClientWs.mostRecentRequest,
30948           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
30949       assertTrue(GrouperClientWs.mostRecentRequest,
30950           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
30951       assertTrue(GrouperClientWs.mostRecentRequest,
30952           !GrouperClientWs.mostRecentRequest.contains("params"));
30953       assertTrue(GrouperClientWs.mostRecentRequest,
30954           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
30955       assertTrue(GrouperClientWs.mostRecentRequest,
30956           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
30957       assertFalse(GrouperClientWs.mostRecentRequest,
30958           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
30959       assertTrue(GrouperClientWs.mostRecentRequest,
30960           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
30961       assertTrue(GrouperClientWs.mostRecentRequest,
30962           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
30963       assertTrue(GrouperClientWs.mostRecentRequest,
30964           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
30965       assertTrue(GrouperClientWs.mostRecentRequest,
30966           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
30967       assertTrue(GrouperClientWs.mostRecentRequest,
30968           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
30969       assertTrue(GrouperClientWs.mostRecentRequest,
30970           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
30971       assertTrue(GrouperClientWs.mostRecentRequest,
30972           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
30973       assertTrue(GrouperClientWs.mostRecentRequest,
30974           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
30975       assertFalse(GrouperClientWs.mostRecentRequest,
30976           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
30977       assertFalse(GrouperClientWs.mostRecentRequest,
30978           GrouperClientWs.mostRecentRequest.contains("theValue"));
30979       assertFalse(GrouperClientWs.mostRecentRequest,
30980           GrouperClientWs.mostRecentRequest.contains(">123<"));
30981       assertFalse(GrouperClientWs.mostRecentRequest,
30982           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
30983       assertFalse(GrouperClientWs.mostRecentRequest,
30984           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
30985       assertTrue(GrouperClientWs.mostRecentRequest,
30986           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
30987       assertTrue(GrouperClientWs.mostRecentRequest,
30988           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
30989       assertTrue(GrouperClientWs.mostRecentRequest,
30990           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
30991       assertTrue(GrouperClientWs.mostRecentRequest,
30992           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
30993 
30994 
30995 
30996       // ######################################################
30997       // Try attributeDef assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups
30998 
30999       baos = new ByteArrayOutputStream();
31000       System.setOut(new PrintStream(baos));
31001 
31002       GrouperClient.main(GrouperClientUtils.splitTrim(
31003           "--operation=getAttributeAssignmentsWs --attributeAssignType=attr_def_asgn --ownerAttributeDefNames=" + ownerAttributeDef.getName()
31004           ,
31005         " "));
31006 
31007       System.out.flush();
31008       output = new String(baos.toByteArray());
31009 
31010       System.setOut(systemOut);
31011 
31012       outputLines = GrouperClientUtils.splitTrim(output, "\n");
31013 
31014       // match: Index: 0: attributeAssignType: attributeDef_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
31015       // match: ^Index: (\d+)\: attributeDef\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
31016       pattern = Pattern
31017           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
31018 
31019       assertEquals(1, GrouperUtil.length(outputLines));
31020 
31021       outputLine = outputLines[0];
31022 
31023       matcher = pattern.matcher(outputLine);
31024 
31025       assertTrue(outputLine, matcher.matches());
31026       assertEquals(outputLine, "0", matcher.group(1));
31027       assertEquals(outputLine, "attr_def_asgn", matcher.group(2));
31028       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
31029       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
31030       assertEquals(outputLine, "assign", matcher.group(5));
31031       assertEquals(outputLine, "123", matcher.group(6));
31032       assertEquals(outputLine, "T", matcher.group(7));
31033       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
31034 
31035       assertTrue(GrouperClientWs.mostRecentRequest,
31036           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
31037       assertTrue(GrouperClientWs.mostRecentRequest,
31038           !GrouperClientWs.mostRecentRequest.contains("<actions>"));
31039       assertTrue(GrouperClientWs.mostRecentRequest,
31040           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
31041       assertTrue(GrouperClientWs.mostRecentRequest,
31042           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
31043       assertTrue(GrouperClientWs.mostRecentRequest,
31044           !GrouperClientWs.mostRecentRequest.contains("enabled"));
31045       assertTrue(GrouperClientWs.mostRecentRequest,
31046           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
31047       assertTrue(GrouperClientWs.mostRecentRequest,
31048           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
31049       assertTrue(GrouperClientWs.mostRecentRequest,
31050           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
31051       assertTrue(GrouperClientWs.mostRecentRequest,
31052           !GrouperClientWs.mostRecentRequest.contains("params"));
31053       assertTrue(GrouperClientWs.mostRecentRequest,
31054           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
31055       assertTrue(GrouperClientWs.mostRecentRequest,
31056           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
31057       assertFalse(GrouperClientWs.mostRecentRequest,
31058           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
31059       assertFalse(GrouperClientWs.mostRecentRequest,
31060           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
31061       assertTrue(GrouperClientWs.mostRecentRequest,
31062           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
31063       assertTrue(GrouperClientWs.mostRecentRequest,
31064           GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
31065       assertTrue(GrouperClientWs.mostRecentRequest,
31066           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
31067       assertTrue(GrouperClientWs.mostRecentRequest,
31068           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
31069       assertTrue(GrouperClientWs.mostRecentRequest,
31070           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
31071       assertTrue(GrouperClientWs.mostRecentRequest,
31072           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
31073       assertTrue(GrouperClientWs.mostRecentRequest,
31074           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
31075       assertFalse(GrouperClientWs.mostRecentRequest,
31076           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
31077       assertFalse(GrouperClientWs.mostRecentRequest,
31078           GrouperClientWs.mostRecentRequest.contains("theValue"));
31079       assertFalse(GrouperClientWs.mostRecentRequest,
31080           GrouperClientWs.mostRecentRequest.contains(">123<"));
31081       assertFalse(GrouperClientWs.mostRecentRequest,
31082           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
31083       assertFalse(GrouperClientWs.mostRecentRequest,
31084           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
31085       assertTrue(GrouperClientWs.mostRecentRequest,
31086           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
31087       assertTrue(GrouperClientWs.mostRecentRequest,
31088           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
31089       assertTrue(GrouperClientWs.mostRecentRequest,
31090           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
31091       assertTrue(GrouperClientWs.mostRecentRequest,
31092           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
31093 
31094 
31095     } finally {
31096       System.setOut(systemOut);
31097     }
31098 
31099   }
31100 
31101 /**
31102    * @throws Exception
31103    */
31104   public void testGetAttributeAssignsMembershipExtraFeatures() throws Exception {
31105 
31106     AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
31107     AttributeDefName attributeDefName2 = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignAssignName");
31108 
31109     final AttributeDef attributeDef = attributeDefName.getAttributeDef();
31110 
31111     attributeDef.setValueType(AttributeDefValueType.string);
31112     attributeDef.setAssignToGroup(false);
31113     attributeDef.setAssignToImmMembership(true);
31114     attributeDef.store();
31115 
31116     final AttributeDef attributeDef2 = attributeDefName2.getAttributeDef();
31117 
31118     attributeDef2.setAssignToGroup(false);
31119     attributeDef2.setAssignToImmMembershipAssn(true);
31120     attributeDef2.setValueType(AttributeDefValueType.integer);
31121     attributeDef2.store();
31122 
31123     Group group = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
31124       .assignGroupNameToEdit("test:groupTestAttrAssign").assignName("test:groupTestAttrAssign").assignCreateParentStemsIfNotExist(true)
31125       .assignDescription("description").save();
31126 
31127     group.addMember(SubjectTestHelper.SUBJ1);
31128 
31129     Membership membership = MembershipFinder.findImmediateMembership(GrouperSession.staticGrouperSession(),
31130         group, SubjectTestHelper.SUBJ1, true);
31131 
31132     AttributeAssignResult attributeAssignResult = membership.getAttributeDelegate().assignAttribute(attributeDefName);
31133     AttributeAssign attributeAssign = attributeAssignResult.getAttributeAssign();
31134     attributeAssign.getValueDelegate().assignValue("abc");
31135 
31136     AttributeAssignResult attributeAssignResult2 = attributeAssign.getAttributeDelegate().assignAttribute(attributeDefName2);
31137     AttributeAssign attributeAssign2 = attributeAssignResult2.getAttributeAssign();
31138     attributeAssign2.getValueDelegate().assignValue("123");
31139 
31140     PrintStream systemOut = System.out;
31141 
31142     ByteArrayOutputStream baos = new ByteArrayOutputStream();
31143     System.setOut(new PrintStream(baos));
31144 
31145     try {
31146 
31147       GrouperClient.main(GrouperClientUtils.splitTrim(
31148           "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem " +
31149           "--attributeDefNames=test:testAttributeAssignDefNameDef " +
31150           "--attributeDefValueType=string --value=abc",
31151           " "));
31152       System.out.flush();
31153       String output = new String(baos.toByteArray());
31154 
31155       System.setOut(systemOut);
31156 
31157       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
31158 
31159       // match: Index: 0: attributeAssignType: group, owner: test:groupTestAttrAssign, attributeDefNameName test:testAttributeAssignDefName, action: assign, values: 15,5,5, enable: T, id: a9c83eeb78c04ae5befcea36272d318c
31160       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
31161       Pattern pattern = Pattern
31162           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
31163 
31164       assertEquals(1, GrouperUtil.length(outputLines));
31165       String outputLine = outputLines[0];
31166 
31167       Matcher matcher = pattern.matcher(outputLines[0]);
31168 
31169       assertTrue(outputLine, matcher.matches());
31170       assertEquals(outputLine, "0", matcher.group(1));
31171       assertEquals(outputLine, "imm_mem", matcher.group(2));
31172       assertEquals(outputLine, membership.getImmediateMembershipId(), matcher.group(3));
31173       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
31174       assertEquals(outputLine, "assign", matcher.group(5));
31175       assertEquals(outputLine, "abc", matcher.group(6));
31176       assertEquals(outputLine, "T", matcher.group(7));
31177       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
31178 
31179       assertTrue(GrouperClientWs.mostRecentRequest,
31180           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
31181       assertTrue(GrouperClientWs.mostRecentRequest,
31182           !GrouperClientWs.mostRecentRequest.contains("actions"));
31183       assertTrue(GrouperClientWs.mostRecentRequest,
31184           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
31185       assertTrue(GrouperClientWs.mostRecentRequest,
31186           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
31187       assertTrue(GrouperClientWs.mostRecentRequest,
31188           !GrouperClientWs.mostRecentRequest.contains("enabled"));
31189       assertTrue(GrouperClientWs.mostRecentRequest,
31190           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
31191       assertTrue(GrouperClientWs.mostRecentRequest,
31192           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
31193       assertTrue(GrouperClientWs.mostRecentRequest,
31194           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
31195       assertTrue(GrouperClientWs.mostRecentRequest,
31196           !GrouperClientWs.mostRecentRequest.contains("params"));
31197       assertTrue(GrouperClientWs.mostRecentRequest,
31198           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
31199       assertTrue(GrouperClientWs.mostRecentRequest,
31200           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
31201       assertTrue(GrouperClientWs.mostRecentRequest,
31202           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
31203       assertTrue(GrouperClientWs.mostRecentRequest,
31204           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
31205       assertTrue(GrouperClientWs.mostRecentRequest,
31206           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
31207       assertTrue(GrouperClientWs.mostRecentRequest,
31208           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
31209       assertTrue(GrouperClientWs.mostRecentRequest,
31210           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
31211       assertTrue(GrouperClientWs.mostRecentRequest,
31212           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
31213       assertTrue(GrouperClientWs.mostRecentRequest,
31214           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
31215       assertTrue(GrouperClientWs.mostRecentRequest,
31216           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
31217       assertTrue(GrouperClientWs.mostRecentRequest,
31218           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
31219       assertTrue(GrouperClientWs.mostRecentRequest,
31220           GrouperClientWs.mostRecentRequest.contains("theValue"));
31221       assertTrue(GrouperClientWs.mostRecentRequest,
31222           GrouperClientWs.mostRecentRequest.contains("abc"));
31223       assertTrue(GrouperClientWs.mostRecentRequest,
31224           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
31225       assertTrue(GrouperClientWs.mostRecentRequest,
31226           !GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
31227       assertTrue(GrouperClientWs.mostRecentRequest,
31228           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
31229       assertTrue(GrouperClientWs.mostRecentRequest,
31230           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
31231       assertTrue(GrouperClientWs.mostRecentRequest,
31232           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
31233       assertTrue(GrouperClientWs.mostRecentRequest,
31234           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
31235       assertTrue(GrouperClientWs.mostRecentRequest,
31236           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
31237       assertTrue(GrouperClientWs.mostRecentRequest,
31238           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
31239 
31240       // ######################################################
31241       // Try wrong value
31242 
31243       baos = new ByteArrayOutputStream();
31244       System.setOut(new PrintStream(baos));
31245 
31246       GrouperClient.main(GrouperClientUtils.splitTrim(
31247           "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem --attributeDefUuids=" + attributeDef.getId() +
31248           " --attributeDefNames=test:testAttributeAssignDefNameDef " +
31249           "--attributeDefValueType=string --value=123",
31250           " "));
31251 
31252 
31253       System.out.flush();
31254       output = new String(baos.toByteArray());
31255 
31256       System.setOut(systemOut);
31257 
31258       outputLines = GrouperClientUtils.splitTrim(output, "\n");
31259 
31260       assertEquals(0, GrouperUtil.length(outputLines));
31261 //      outputLine = outputLines[0];
31262 //
31263 //      matcher = pattern.matcher(outputLines[0]);
31264 
31265       assertTrue(GrouperClientWs.mostRecentRequest,
31266           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
31267       assertTrue(GrouperClientWs.mostRecentRequest,
31268           !GrouperClientWs.mostRecentRequest.contains("actions"));
31269       assertTrue(GrouperClientWs.mostRecentRequest,
31270           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
31271       assertTrue(GrouperClientWs.mostRecentRequest,
31272           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
31273       assertTrue(GrouperClientWs.mostRecentRequest,
31274           !GrouperClientWs.mostRecentRequest.contains("enabled"));
31275       assertTrue(GrouperClientWs.mostRecentRequest,
31276           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
31277       assertTrue(GrouperClientWs.mostRecentRequest,
31278           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
31279       assertTrue(GrouperClientWs.mostRecentRequest,
31280           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
31281       assertTrue(GrouperClientWs.mostRecentRequest,
31282           !GrouperClientWs.mostRecentRequest.contains("params"));
31283       assertTrue(GrouperClientWs.mostRecentRequest,
31284           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
31285       assertTrue(GrouperClientWs.mostRecentRequest,
31286           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
31287       assertTrue(GrouperClientWs.mostRecentRequest,
31288           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
31289       assertTrue(GrouperClientWs.mostRecentRequest,
31290           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
31291       assertTrue(GrouperClientWs.mostRecentRequest,
31292           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
31293       assertTrue(GrouperClientWs.mostRecentRequest,
31294           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
31295       assertTrue(GrouperClientWs.mostRecentRequest,
31296           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
31297       assertTrue(GrouperClientWs.mostRecentRequest,
31298           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
31299       assertTrue(GrouperClientWs.mostRecentRequest,
31300           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
31301       assertTrue(GrouperClientWs.mostRecentRequest,
31302           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
31303       assertTrue(GrouperClientWs.mostRecentRequest,
31304           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
31305       assertTrue(GrouperClientWs.mostRecentRequest,
31306           GrouperClientWs.mostRecentRequest.contains("theValue"));
31307       assertTrue(GrouperClientWs.mostRecentRequest,
31308           GrouperClientWs.mostRecentRequest.contains(">123<"));
31309       assertTrue(GrouperClientWs.mostRecentRequest,
31310           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
31311       assertTrue(GrouperClientWs.mostRecentRequest,
31312           !GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
31313       assertTrue(GrouperClientWs.mostRecentRequest,
31314           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
31315       assertTrue(GrouperClientWs.mostRecentRequest,
31316           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
31317       assertTrue(GrouperClientWs.mostRecentRequest,
31318           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
31319       assertTrue(GrouperClientWs.mostRecentRequest,
31320           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
31321       assertTrue(GrouperClientWs.mostRecentRequest,
31322           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
31323       assertTrue(GrouperClientWs.mostRecentRequest,
31324           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
31325 
31326 
31327       // ######################################################
31328       // Try wrong id
31329 
31330       baos = new ByteArrayOutputStream();
31331       System.setOut(new PrintStream(baos));
31332 
31333       try {
31334         GrouperClient.main(GrouperClientUtils.splitTrim(
31335             " --operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem --attributeDefUuids=123" + attributeDef.getId() +
31336             " --attributeDefNames=test:testAttributeAssignDefNameDef " +
31337             "--attributeDefValueType=string --value=123",
31338             " "));
31339         fail("Shouldnt get here");
31340       } catch (GcWebServiceError gwse) {
31341         //ignore
31342       }
31343 
31344       // ######################################################
31345       // Try correct attributeDefType
31346 
31347       baos = new ByteArrayOutputStream();
31348       System.setOut(new PrintStream(baos));
31349 
31350       GrouperClient.main(GrouperClientUtils.splitTrim(
31351           "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem --attributeDefUuids=" + attributeDef.getId() +
31352           " --attributeDefValueType=string --value=abc --attributeDefType=attr",
31353           " "));
31354 
31355 
31356       System.out.flush();
31357       output = new String(baos.toByteArray());
31358 
31359       System.setOut(systemOut);
31360 
31361       outputLines = GrouperClientUtils.splitTrim(output, "\n");
31362 
31363       // match: Index: 0: attributeAssignType: group, owner: test:groupTestAttrAssign, attributeDefNameName test:testAttributeAssignDefName, action: assign, values: 15,5,5, enable: T, id: a9c83eeb78c04ae5befcea36272d318c
31364       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
31365       pattern = Pattern
31366           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
31367 
31368       assertEquals(1, GrouperUtil.length(outputLines));
31369       outputLine = outputLines[0];
31370 
31371       matcher = pattern.matcher(outputLines[0]);
31372 
31373       assertTrue(outputLine, matcher.matches());
31374       assertEquals(outputLine, "0", matcher.group(1));
31375       assertEquals(outputLine, "imm_mem", matcher.group(2));
31376       assertEquals(outputLine, membership.getImmediateMembershipId(), matcher.group(3));
31377       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
31378       assertEquals(outputLine, "assign", matcher.group(5));
31379       assertEquals(outputLine, "abc", matcher.group(6));
31380       assertEquals(outputLine, "T", matcher.group(7));
31381       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
31382 
31383       assertTrue(GrouperClientWs.mostRecentRequest,
31384           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
31385       assertTrue(GrouperClientWs.mostRecentRequest,
31386           !GrouperClientWs.mostRecentRequest.contains("actions"));
31387       assertTrue(GrouperClientWs.mostRecentRequest,
31388           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
31389       assertTrue(GrouperClientWs.mostRecentRequest,
31390           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
31391       assertTrue(GrouperClientWs.mostRecentRequest,
31392           !GrouperClientWs.mostRecentRequest.contains("enabled"));
31393       assertTrue(GrouperClientWs.mostRecentRequest,
31394           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
31395       assertTrue(GrouperClientWs.mostRecentRequest,
31396           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
31397       assertTrue(GrouperClientWs.mostRecentRequest,
31398           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
31399       assertTrue(GrouperClientWs.mostRecentRequest,
31400           !GrouperClientWs.mostRecentRequest.contains("params"));
31401       assertTrue(GrouperClientWs.mostRecentRequest,
31402           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
31403       assertTrue(GrouperClientWs.mostRecentRequest,
31404           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
31405       assertTrue(GrouperClientWs.mostRecentRequest,
31406           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
31407       assertTrue(GrouperClientWs.mostRecentRequest,
31408           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
31409       assertTrue(GrouperClientWs.mostRecentRequest,
31410           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
31411       assertTrue(GrouperClientWs.mostRecentRequest,
31412           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
31413       assertTrue(GrouperClientWs.mostRecentRequest,
31414           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
31415       assertTrue(GrouperClientWs.mostRecentRequest,
31416           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
31417       assertTrue(GrouperClientWs.mostRecentRequest,
31418           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
31419       assertTrue(GrouperClientWs.mostRecentRequest,
31420           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
31421       assertTrue(GrouperClientWs.mostRecentRequest,
31422           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
31423       assertTrue(GrouperClientWs.mostRecentRequest,
31424           GrouperClientWs.mostRecentRequest.contains("theValue"));
31425       assertTrue(GrouperClientWs.mostRecentRequest,
31426           GrouperClientWs.mostRecentRequest.contains("abc"));
31427       assertTrue(GrouperClientWs.mostRecentRequest,
31428           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
31429       assertTrue(GrouperClientWs.mostRecentRequest,
31430           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
31431       assertTrue(GrouperClientWs.mostRecentRequest,
31432           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
31433       assertTrue(GrouperClientWs.mostRecentRequest,
31434           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
31435       assertTrue(GrouperClientWs.mostRecentRequest,
31436           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
31437       assertTrue(GrouperClientWs.mostRecentRequest,
31438           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
31439       assertTrue(GrouperClientWs.mostRecentRequest,
31440           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
31441       assertTrue(GrouperClientWs.mostRecentRequest,
31442           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
31443 
31444       // ######################################################
31445       // Try wrong attributeDefType
31446 
31447       baos = new ByteArrayOutputStream();
31448       System.setOut(new PrintStream(baos));
31449 
31450       GrouperClient.main(GrouperClientUtils.splitTrim(
31451           "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem --attributeDefUuids=" + attributeDef.getId() +
31452           " --attributeDefValueType=string --value=abc --attributeDefType=limit",
31453           " "));
31454 
31455       System.out.flush();
31456       output = new String(baos.toByteArray());
31457 
31458       System.setOut(systemOut);
31459 
31460       outputLines = GrouperClientUtils.splitTrim(output, "\n");
31461 
31462       // match: Index: 0: attributeAssignType: group, owner: test:groupTestAttrAssign, attributeDefNameName test:testAttributeAssignDefName, action: assign, values: 15,5,5, enable: T, id: a9c83eeb78c04ae5befcea36272d318c
31463       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
31464       pattern = Pattern
31465           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
31466 
31467       assertEquals(0, GrouperUtil.length(outputLines));
31468 
31469       assertTrue(GrouperClientWs.mostRecentRequest,
31470           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
31471       assertTrue(GrouperClientWs.mostRecentRequest,
31472           !GrouperClientWs.mostRecentRequest.contains("actions"));
31473       assertTrue(GrouperClientWs.mostRecentRequest,
31474           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
31475       assertTrue(GrouperClientWs.mostRecentRequest,
31476           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
31477       assertTrue(GrouperClientWs.mostRecentRequest,
31478           !GrouperClientWs.mostRecentRequest.contains("enabled"));
31479       assertTrue(GrouperClientWs.mostRecentRequest,
31480           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
31481       assertTrue(GrouperClientWs.mostRecentRequest,
31482           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
31483       assertTrue(GrouperClientWs.mostRecentRequest,
31484           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
31485       assertTrue(GrouperClientWs.mostRecentRequest,
31486           !GrouperClientWs.mostRecentRequest.contains("params"));
31487       assertTrue(GrouperClientWs.mostRecentRequest,
31488           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
31489       assertTrue(GrouperClientWs.mostRecentRequest,
31490           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
31491       assertTrue(GrouperClientWs.mostRecentRequest,
31492           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
31493       assertTrue(GrouperClientWs.mostRecentRequest,
31494           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
31495       assertTrue(GrouperClientWs.mostRecentRequest,
31496           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
31497       assertTrue(GrouperClientWs.mostRecentRequest,
31498           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
31499       assertTrue(GrouperClientWs.mostRecentRequest,
31500           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
31501       assertTrue(GrouperClientWs.mostRecentRequest,
31502           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
31503       assertTrue(GrouperClientWs.mostRecentRequest,
31504           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
31505       assertTrue(GrouperClientWs.mostRecentRequest,
31506           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
31507       assertTrue(GrouperClientWs.mostRecentRequest,
31508           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
31509       assertTrue(GrouperClientWs.mostRecentRequest,
31510           GrouperClientWs.mostRecentRequest.contains("theValue"));
31511       assertTrue(GrouperClientWs.mostRecentRequest,
31512           GrouperClientWs.mostRecentRequest.contains("abc"));
31513       assertTrue(GrouperClientWs.mostRecentRequest,
31514           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
31515       assertTrue(GrouperClientWs.mostRecentRequest,
31516           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
31517       assertTrue(GrouperClientWs.mostRecentRequest,
31518           GrouperClientWs.mostRecentRequest.contains("limit"));
31519       assertTrue(GrouperClientWs.mostRecentRequest,
31520           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
31521       assertTrue(GrouperClientWs.mostRecentRequest,
31522           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
31523       assertTrue(GrouperClientWs.mostRecentRequest,
31524           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
31525       assertTrue(GrouperClientWs.mostRecentRequest,
31526           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
31527       assertTrue(GrouperClientWs.mostRecentRequest,
31528           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
31529       assertTrue(GrouperClientWs.mostRecentRequest,
31530           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
31531 
31532       // ######################################################
31533       // Try group assignment on assignment by attributeDef
31534 
31535       baos = new ByteArrayOutputStream();
31536       System.setOut(new PrintStream(baos));
31537 
31538       GrouperClient.main(GrouperClientUtils.splitTrim(
31539           "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --attributeDefUuids=" + attributeDef2.getId(),
31540           " "));
31541 
31542       System.out.flush();
31543       output = new String(baos.toByteArray());
31544 
31545       System.setOut(systemOut);
31546 
31547       outputLines = GrouperClientUtils.splitTrim(output, "\n");
31548 
31549       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
31550       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
31551       pattern = Pattern
31552           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
31553 
31554       assertEquals(1, GrouperUtil.length(outputLines));
31555       outputLine = outputLines[0];
31556 
31557       matcher = pattern.matcher(outputLines[0]);
31558 
31559       assertTrue(outputLine, matcher.matches());
31560       assertEquals(outputLine, "0", matcher.group(1));
31561       assertEquals(outputLine, "imm_mem_asgn", matcher.group(2));
31562       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
31563       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
31564       assertEquals(outputLine, "assign", matcher.group(5));
31565       assertEquals(outputLine, "123", matcher.group(6));
31566       assertEquals(outputLine, "T", matcher.group(7));
31567       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
31568 
31569       assertTrue(GrouperClientWs.mostRecentRequest,
31570           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
31571       assertTrue(GrouperClientWs.mostRecentRequest,
31572           !GrouperClientWs.mostRecentRequest.contains("actions"));
31573       assertTrue(GrouperClientWs.mostRecentRequest,
31574           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
31575       assertTrue(GrouperClientWs.mostRecentRequest,
31576           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
31577       assertTrue(GrouperClientWs.mostRecentRequest,
31578           !GrouperClientWs.mostRecentRequest.contains("enabled"));
31579       assertTrue(GrouperClientWs.mostRecentRequest,
31580           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
31581       assertTrue(GrouperClientWs.mostRecentRequest,
31582           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
31583       assertTrue(GrouperClientWs.mostRecentRequest,
31584           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
31585       assertTrue(GrouperClientWs.mostRecentRequest,
31586           !GrouperClientWs.mostRecentRequest.contains("params"));
31587       assertTrue(GrouperClientWs.mostRecentRequest,
31588           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
31589       assertTrue(GrouperClientWs.mostRecentRequest,
31590           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
31591       assertTrue(GrouperClientWs.mostRecentRequest,
31592           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
31593       assertTrue(GrouperClientWs.mostRecentRequest,
31594           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
31595       assertTrue(GrouperClientWs.mostRecentRequest,
31596           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
31597       assertTrue(GrouperClientWs.mostRecentRequest,
31598           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
31599       assertTrue(GrouperClientWs.mostRecentRequest,
31600           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
31601       assertTrue(GrouperClientWs.mostRecentRequest,
31602           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
31603       assertTrue(GrouperClientWs.mostRecentRequest,
31604           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
31605       assertTrue(GrouperClientWs.mostRecentRequest,
31606           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
31607       assertFalse(GrouperClientWs.mostRecentRequest,
31608           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
31609       assertFalse(GrouperClientWs.mostRecentRequest,
31610           GrouperClientWs.mostRecentRequest.contains("theValue"));
31611       assertFalse(GrouperClientWs.mostRecentRequest,
31612           GrouperClientWs.mostRecentRequest.contains(">abc<"));
31613       assertTrue(GrouperClientWs.mostRecentRequest,
31614           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
31615       assertFalse(GrouperClientWs.mostRecentRequest,
31616           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
31617       assertTrue(GrouperClientWs.mostRecentRequest,
31618           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
31619       assertTrue(GrouperClientWs.mostRecentRequest,
31620           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
31621       assertTrue(GrouperClientWs.mostRecentRequest,
31622           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
31623       assertTrue(GrouperClientWs.mostRecentRequest,
31624           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
31625       assertTrue(GrouperClientWs.mostRecentRequest,
31626           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
31627       assertTrue(GrouperClientWs.mostRecentRequest,
31628           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
31629 
31630       // ######################################################
31631       // Try group assignment on assignment by attributeDef with wrong id
31632 
31633       baos = new ByteArrayOutputStream();
31634       System.setOut(new PrintStream(baos));
31635 
31636       try {
31637         GrouperClient.main(GrouperClientUtils.splitTrim(
31638             "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --attributeDefUuids=1" + attributeDef2.getId(),
31639             " "));
31640 
31641         System.out.flush();
31642         output = new String(baos.toByteArray());
31643 
31644         System.setOut(systemOut);
31645 
31646         outputLines = GrouperClientUtils.splitTrim(output, "\n");
31647 
31648         // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
31649         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
31650         pattern = Pattern
31651             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
31652 
31653         assertEquals(0, GrouperUtil.length(outputLines));
31654         fail("Why did it not fail?");
31655       } catch (Exception e) {
31656         //good
31657       }
31658       assertTrue(GrouperClientWs.mostRecentRequest,
31659           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
31660       assertTrue(GrouperClientWs.mostRecentRequest,
31661           !GrouperClientWs.mostRecentRequest.contains("actions"));
31662       assertTrue(GrouperClientWs.mostRecentRequest,
31663           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
31664       assertTrue(GrouperClientWs.mostRecentRequest,
31665           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
31666       assertTrue(GrouperClientWs.mostRecentRequest,
31667           !GrouperClientWs.mostRecentRequest.contains("enabled"));
31668       assertTrue(GrouperClientWs.mostRecentRequest,
31669           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
31670       assertTrue(GrouperClientWs.mostRecentRequest,
31671           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
31672       assertTrue(GrouperClientWs.mostRecentRequest,
31673           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
31674       assertTrue(GrouperClientWs.mostRecentRequest,
31675           !GrouperClientWs.mostRecentRequest.contains("params"));
31676       assertTrue(GrouperClientWs.mostRecentRequest,
31677           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
31678       assertTrue(GrouperClientWs.mostRecentRequest,
31679           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
31680       assertTrue(GrouperClientWs.mostRecentRequest,
31681           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
31682       assertTrue(GrouperClientWs.mostRecentRequest,
31683           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
31684       assertTrue(GrouperClientWs.mostRecentRequest,
31685           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
31686       assertTrue(GrouperClientWs.mostRecentRequest,
31687           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
31688       assertTrue(GrouperClientWs.mostRecentRequest,
31689           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
31690       assertTrue(GrouperClientWs.mostRecentRequest,
31691           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
31692       assertTrue(GrouperClientWs.mostRecentRequest,
31693           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
31694       assertTrue(GrouperClientWs.mostRecentRequest,
31695           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
31696       assertFalse(GrouperClientWs.mostRecentRequest,
31697           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
31698       assertFalse(GrouperClientWs.mostRecentRequest,
31699           GrouperClientWs.mostRecentRequest.contains("theValue"));
31700       assertFalse(GrouperClientWs.mostRecentRequest,
31701           GrouperClientWs.mostRecentRequest.contains("abc"));
31702       assertTrue(GrouperClientWs.mostRecentRequest,
31703           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
31704       assertFalse(GrouperClientWs.mostRecentRequest,
31705           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
31706       assertTrue(GrouperClientWs.mostRecentRequest,
31707           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
31708       assertTrue(GrouperClientWs.mostRecentRequest,
31709           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
31710       assertTrue(GrouperClientWs.mostRecentRequest,
31711           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
31712       assertTrue(GrouperClientWs.mostRecentRequest,
31713           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
31714       assertTrue(GrouperClientWs.mostRecentRequest,
31715           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
31716       assertTrue(GrouperClientWs.mostRecentRequest,
31717           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
31718 
31719 
31720       // ######################################################
31721       // Try group assignment on assignment by attributeDef and value
31722 
31723       baos = new ByteArrayOutputStream();
31724       System.setOut(new PrintStream(baos));
31725 
31726       GrouperClient.main(GrouperClientUtils.splitTrim(
31727           "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --attributeDefUuids=" + attributeDef2.getId()
31728           + " --attributeDefValueType=integer --value=123 ",
31729         " "));
31730 
31731       System.out.flush();
31732       output = new String(baos.toByteArray());
31733 
31734       System.setOut(systemOut);
31735 
31736       outputLines = GrouperClientUtils.splitTrim(output, "\n");
31737 
31738       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
31739       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
31740       pattern = Pattern
31741           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
31742 
31743       assertEquals(1, GrouperUtil.length(outputLines));
31744       outputLine = outputLines[0];
31745 
31746       matcher = pattern.matcher(outputLines[0]);
31747 
31748       assertTrue(outputLine, matcher.matches());
31749       assertEquals(outputLine, "0", matcher.group(1));
31750       assertEquals(outputLine, "imm_mem_asgn", matcher.group(2));
31751       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
31752       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
31753       assertEquals(outputLine, "assign", matcher.group(5));
31754       assertEquals(outputLine, "123", matcher.group(6));
31755       assertEquals(outputLine, "T", matcher.group(7));
31756       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
31757 
31758       assertTrue(GrouperClientWs.mostRecentRequest,
31759           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
31760       assertTrue(GrouperClientWs.mostRecentRequest,
31761           !GrouperClientWs.mostRecentRequest.contains("actions"));
31762       assertTrue(GrouperClientWs.mostRecentRequest,
31763           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
31764       assertTrue(GrouperClientWs.mostRecentRequest,
31765           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
31766       assertTrue(GrouperClientWs.mostRecentRequest,
31767           !GrouperClientWs.mostRecentRequest.contains("enabled"));
31768       assertTrue(GrouperClientWs.mostRecentRequest,
31769           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
31770       assertTrue(GrouperClientWs.mostRecentRequest,
31771           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
31772       assertTrue(GrouperClientWs.mostRecentRequest,
31773           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
31774       assertTrue(GrouperClientWs.mostRecentRequest,
31775           !GrouperClientWs.mostRecentRequest.contains("params"));
31776       assertTrue(GrouperClientWs.mostRecentRequest,
31777           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
31778       assertTrue(GrouperClientWs.mostRecentRequest,
31779           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
31780       assertTrue(GrouperClientWs.mostRecentRequest,
31781           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
31782       assertTrue(GrouperClientWs.mostRecentRequest,
31783           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
31784       assertTrue(GrouperClientWs.mostRecentRequest,
31785           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
31786       assertTrue(GrouperClientWs.mostRecentRequest,
31787           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
31788       assertTrue(GrouperClientWs.mostRecentRequest,
31789           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
31790       assertTrue(GrouperClientWs.mostRecentRequest,
31791           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
31792       assertTrue(GrouperClientWs.mostRecentRequest,
31793           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
31794       assertTrue(GrouperClientWs.mostRecentRequest,
31795           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
31796       assertTrue(GrouperClientWs.mostRecentRequest,
31797           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
31798       assertTrue(GrouperClientWs.mostRecentRequest,
31799           GrouperClientWs.mostRecentRequest.contains("theValue"));
31800       assertTrue(GrouperClientWs.mostRecentRequest,
31801           GrouperClientWs.mostRecentRequest.contains(">123<"));
31802       assertTrue(GrouperClientWs.mostRecentRequest,
31803           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
31804       assertFalse(GrouperClientWs.mostRecentRequest,
31805           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
31806       assertTrue(GrouperClientWs.mostRecentRequest,
31807           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
31808       assertTrue(GrouperClientWs.mostRecentRequest,
31809           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
31810       assertTrue(GrouperClientWs.mostRecentRequest,
31811           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
31812       assertTrue(GrouperClientWs.mostRecentRequest,
31813           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
31814       assertTrue(GrouperClientWs.mostRecentRequest,
31815           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
31816       assertTrue(GrouperClientWs.mostRecentRequest,
31817           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
31818 
31819 
31820       // ######################################################
31821       // Try group assignment on assignment by attributeDef and wrong value
31822 
31823       baos = new ByteArrayOutputStream();
31824       System.setOut(new PrintStream(baos));
31825 
31826       GrouperClient.main(GrouperClientUtils.splitTrim(
31827           "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --attributeDefUuids=" + attributeDef2.getId()
31828           + " --attributeDefValueType=integer --value=1234 ",
31829         " "));
31830 
31831       System.out.flush();
31832       output = new String(baos.toByteArray());
31833 
31834       System.setOut(systemOut);
31835 
31836       outputLines = GrouperClientUtils.splitTrim(output, "\n");
31837 
31838       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
31839       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
31840       pattern = Pattern
31841           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
31842 
31843       assertEquals(0, GrouperUtil.length(outputLines));
31844 
31845       assertTrue(GrouperClientWs.mostRecentRequest,
31846           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
31847       assertTrue(GrouperClientWs.mostRecentRequest,
31848           !GrouperClientWs.mostRecentRequest.contains("actions"));
31849       assertTrue(GrouperClientWs.mostRecentRequest,
31850           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
31851       assertTrue(GrouperClientWs.mostRecentRequest,
31852           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
31853       assertTrue(GrouperClientWs.mostRecentRequest,
31854           !GrouperClientWs.mostRecentRequest.contains("enabled"));
31855       assertTrue(GrouperClientWs.mostRecentRequest,
31856           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
31857       assertTrue(GrouperClientWs.mostRecentRequest,
31858           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
31859       assertTrue(GrouperClientWs.mostRecentRequest,
31860           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
31861       assertTrue(GrouperClientWs.mostRecentRequest,
31862           !GrouperClientWs.mostRecentRequest.contains("params"));
31863       assertTrue(GrouperClientWs.mostRecentRequest,
31864           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
31865       assertTrue(GrouperClientWs.mostRecentRequest,
31866           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
31867       assertTrue(GrouperClientWs.mostRecentRequest,
31868           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
31869       assertTrue(GrouperClientWs.mostRecentRequest,
31870           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
31871       assertTrue(GrouperClientWs.mostRecentRequest,
31872           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
31873       assertTrue(GrouperClientWs.mostRecentRequest,
31874           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
31875       assertTrue(GrouperClientWs.mostRecentRequest,
31876           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
31877       assertTrue(GrouperClientWs.mostRecentRequest,
31878           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
31879       assertTrue(GrouperClientWs.mostRecentRequest,
31880           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
31881       assertTrue(GrouperClientWs.mostRecentRequest,
31882           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
31883       assertTrue(GrouperClientWs.mostRecentRequest,
31884           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
31885       assertTrue(GrouperClientWs.mostRecentRequest,
31886           GrouperClientWs.mostRecentRequest.contains("theValue"));
31887       assertTrue(GrouperClientWs.mostRecentRequest,
31888           GrouperClientWs.mostRecentRequest.contains("1234"));
31889       assertTrue(GrouperClientWs.mostRecentRequest,
31890           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
31891       assertFalse(GrouperClientWs.mostRecentRequest,
31892           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
31893       assertTrue(GrouperClientWs.mostRecentRequest,
31894           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
31895       assertTrue(GrouperClientWs.mostRecentRequest,
31896           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
31897       assertTrue(GrouperClientWs.mostRecentRequest,
31898           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
31899       assertTrue(GrouperClientWs.mostRecentRequest,
31900           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
31901       assertTrue(GrouperClientWs.mostRecentRequest,
31902           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
31903       assertTrue(GrouperClientWs.mostRecentRequest,
31904           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
31905 
31906 
31907       // ######################################################
31908       // Try group assignment on assignment by attributeDef and value
31909 
31910       baos = new ByteArrayOutputStream();
31911       System.setOut(new PrintStream(baos));
31912 
31913       GrouperClient.main(GrouperClientUtils.splitTrim(
31914           "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --attributeDefUuids=" + attributeDef2.getId()
31915           + " --includeAssignmentsFromAssignments=T ",
31916         " "));
31917 
31918       System.out.flush();
31919       output = new String(baos.toByteArray());
31920 
31921       System.setOut(systemOut);
31922 
31923       outputLines = GrouperClientUtils.splitTrim(output, "\n");
31924 
31925       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
31926       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
31927       pattern = Pattern
31928           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
31929 
31930       assertEquals(2, GrouperUtil.length(outputLines));
31931       outputLine = outputLines[0];
31932 
31933       matcher = pattern.matcher(outputLine);
31934 
31935       assertTrue(outputLine, matcher.matches());
31936       assertEquals(outputLine, "0", matcher.group(1));
31937       assertEquals(outputLine, "imm_mem", matcher.group(2));
31938       assertEquals(outputLine, membership.getImmediateMembershipId(), matcher.group(3));
31939       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
31940       assertEquals(outputLine, "assign", matcher.group(5));
31941       assertEquals(outputLine, "abc", matcher.group(6));
31942       assertEquals(outputLine, "T", matcher.group(7));
31943       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
31944 
31945       outputLine = outputLines[1];
31946 
31947       matcher = pattern.matcher(outputLine);
31948 
31949       assertTrue(outputLine, matcher.matches());
31950       assertEquals(outputLine, "1", matcher.group(1));
31951       assertEquals(outputLine, "imm_mem_asgn", matcher.group(2));
31952       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
31953       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
31954       assertEquals(outputLine, "assign", matcher.group(5));
31955       assertEquals(outputLine, "123", matcher.group(6));
31956       assertEquals(outputLine, "T", matcher.group(7));
31957       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
31958 
31959       assertTrue(GrouperClientWs.mostRecentRequest,
31960           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
31961       assertTrue(GrouperClientWs.mostRecentRequest,
31962           !GrouperClientWs.mostRecentRequest.contains("actions"));
31963       assertTrue(GrouperClientWs.mostRecentRequest,
31964           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
31965       assertTrue(GrouperClientWs.mostRecentRequest,
31966           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
31967       assertTrue(GrouperClientWs.mostRecentRequest,
31968           !GrouperClientWs.mostRecentRequest.contains("enabled"));
31969       assertTrue(GrouperClientWs.mostRecentRequest,
31970           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
31971       assertTrue(GrouperClientWs.mostRecentRequest,
31972           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
31973       assertTrue(GrouperClientWs.mostRecentRequest,
31974           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
31975       assertTrue(GrouperClientWs.mostRecentRequest,
31976           !GrouperClientWs.mostRecentRequest.contains("params"));
31977       assertTrue(GrouperClientWs.mostRecentRequest,
31978           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
31979       assertTrue(GrouperClientWs.mostRecentRequest,
31980           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
31981       assertTrue(GrouperClientWs.mostRecentRequest,
31982           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
31983       assertTrue(GrouperClientWs.mostRecentRequest,
31984           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
31985       assertTrue(GrouperClientWs.mostRecentRequest,
31986           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
31987       assertTrue(GrouperClientWs.mostRecentRequest,
31988           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
31989       assertTrue(GrouperClientWs.mostRecentRequest,
31990           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
31991       assertTrue(GrouperClientWs.mostRecentRequest,
31992           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
31993       assertTrue(GrouperClientWs.mostRecentRequest,
31994           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
31995       assertTrue(GrouperClientWs.mostRecentRequest,
31996           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
31997       assertFalse(GrouperClientWs.mostRecentRequest,
31998           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
31999       assertFalse(GrouperClientWs.mostRecentRequest,
32000           GrouperClientWs.mostRecentRequest.contains("theValue"));
32001       assertFalse(GrouperClientWs.mostRecentRequest,
32002           GrouperClientWs.mostRecentRequest.contains(">123<"));
32003       assertTrue(GrouperClientWs.mostRecentRequest,
32004           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
32005       assertFalse(GrouperClientWs.mostRecentRequest,
32006           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
32007       assertTrue(GrouperClientWs.mostRecentRequest,
32008           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
32009       assertTrue(GrouperClientWs.mostRecentRequest,
32010           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
32011       assertTrue(GrouperClientWs.mostRecentRequest,
32012           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
32013       assertTrue(GrouperClientWs.mostRecentRequest,
32014           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
32015       assertTrue(GrouperClientWs.mostRecentRequest,
32016           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
32017       assertTrue(GrouperClientWs.mostRecentRequest,
32018           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
32019 
32020 
32021       // ######################################################
32022       // Try group assignment on assignment by owner attribute assign id with wrong id
32023 
32024       baos = new ByteArrayOutputStream();
32025       System.setOut(new PrintStream(baos));
32026 
32027       try {
32028         GrouperClient.main(GrouperClientUtils.splitTrim(
32029             "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --assignAssignOwnerAttributeAssignUuids=1" + attributeAssign.getId()
32030             ,
32031           " "));
32032 
32033         System.out.flush();
32034         output = new String(baos.toByteArray());
32035 
32036         System.setOut(systemOut);
32037 
32038         outputLines = GrouperClientUtils.splitTrim(output, "\n");
32039 
32040         // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
32041         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
32042         pattern = Pattern
32043             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
32044 
32045         assertEquals(0, GrouperUtil.length(outputLines));
32046         fail("Shouldnt get here");
32047       } catch (Exception e) {
32048         //good
32049       } finally {
32050         System.setOut(systemOut);
32051 
32052       }
32053 
32054       assertTrue(GrouperClientWs.mostRecentRequest,
32055           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
32056       assertTrue(GrouperClientWs.mostRecentRequest,
32057           !GrouperClientWs.mostRecentRequest.contains("actions"));
32058       assertTrue(GrouperClientWs.mostRecentRequest,
32059           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
32060       assertTrue(GrouperClientWs.mostRecentRequest,
32061           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
32062       assertTrue(GrouperClientWs.mostRecentRequest,
32063           !GrouperClientWs.mostRecentRequest.contains("enabled"));
32064       assertTrue(GrouperClientWs.mostRecentRequest,
32065           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
32066       assertTrue(GrouperClientWs.mostRecentRequest,
32067           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
32068       assertTrue(GrouperClientWs.mostRecentRequest,
32069           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
32070       assertTrue(GrouperClientWs.mostRecentRequest,
32071           !GrouperClientWs.mostRecentRequest.contains("params"));
32072       assertTrue(GrouperClientWs.mostRecentRequest,
32073           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
32074       assertTrue(GrouperClientWs.mostRecentRequest,
32075           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
32076       assertFalse(GrouperClientWs.mostRecentRequest,
32077           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
32078       assertTrue(GrouperClientWs.mostRecentRequest,
32079           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
32080       assertTrue(GrouperClientWs.mostRecentRequest,
32081           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
32082       assertTrue(GrouperClientWs.mostRecentRequest,
32083           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
32084       assertTrue(GrouperClientWs.mostRecentRequest,
32085           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
32086       assertTrue(GrouperClientWs.mostRecentRequest,
32087           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
32088       assertTrue(GrouperClientWs.mostRecentRequest,
32089           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
32090       assertTrue(GrouperClientWs.mostRecentRequest,
32091           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
32092       assertTrue(GrouperClientWs.mostRecentRequest,
32093           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
32094       assertFalse(GrouperClientWs.mostRecentRequest,
32095           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
32096       assertFalse(GrouperClientWs.mostRecentRequest,
32097           GrouperClientWs.mostRecentRequest.contains("theValue"));
32098       assertFalse(GrouperClientWs.mostRecentRequest,
32099           GrouperClientWs.mostRecentRequest.contains(">123<"));
32100       assertFalse(GrouperClientWs.mostRecentRequest,
32101           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
32102       assertFalse(GrouperClientWs.mostRecentRequest,
32103           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
32104       assertTrue(GrouperClientWs.mostRecentRequest,
32105           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
32106       assertTrue(GrouperClientWs.mostRecentRequest,
32107           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
32108       assertTrue(GrouperClientWs.mostRecentRequest,
32109           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
32110       assertTrue(GrouperClientWs.mostRecentRequest,
32111           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
32112       assertTrue(GrouperClientWs.mostRecentRequest,
32113           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
32114       assertTrue(GrouperClientWs.mostRecentRequest,
32115           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
32116 
32117       // ######################################################
32118       // Try group assignment on assignment by owner attribute assign id
32119 
32120       baos = new ByteArrayOutputStream();
32121       System.setOut(new PrintStream(baos));
32122 
32123       GrouperClient.main(GrouperClientUtils.splitTrim(
32124           "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --assignAssignOwnerAttributeAssignUuids=" + attributeAssign.getId()
32125           ,
32126         " "));
32127 
32128       System.out.flush();
32129       output = new String(baos.toByteArray());
32130 
32131       System.setOut(systemOut);
32132 
32133       outputLines = GrouperClientUtils.splitTrim(output, "\n");
32134 
32135       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
32136       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
32137       pattern = Pattern
32138           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
32139 
32140       assertEquals(1, GrouperUtil.length(outputLines));
32141 
32142       outputLine = outputLines[0];
32143 
32144       matcher = pattern.matcher(outputLine);
32145 
32146       assertTrue(outputLine, matcher.matches());
32147       assertEquals(outputLine, "0", matcher.group(1));
32148       assertEquals(outputLine, "imm_mem_asgn", matcher.group(2));
32149       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
32150       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
32151       assertEquals(outputLine, "assign", matcher.group(5));
32152       assertEquals(outputLine, "123", matcher.group(6));
32153       assertEquals(outputLine, "T", matcher.group(7));
32154       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
32155 
32156       assertTrue(GrouperClientWs.mostRecentRequest,
32157           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
32158       assertTrue(GrouperClientWs.mostRecentRequest,
32159           !GrouperClientWs.mostRecentRequest.contains("actions"));
32160       assertTrue(GrouperClientWs.mostRecentRequest,
32161           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
32162       assertTrue(GrouperClientWs.mostRecentRequest,
32163           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
32164       assertTrue(GrouperClientWs.mostRecentRequest,
32165           !GrouperClientWs.mostRecentRequest.contains("enabled"));
32166       assertTrue(GrouperClientWs.mostRecentRequest,
32167           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
32168       assertTrue(GrouperClientWs.mostRecentRequest,
32169           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
32170       assertTrue(GrouperClientWs.mostRecentRequest,
32171           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
32172       assertTrue(GrouperClientWs.mostRecentRequest,
32173           !GrouperClientWs.mostRecentRequest.contains("params"));
32174       assertTrue(GrouperClientWs.mostRecentRequest,
32175           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
32176       assertTrue(GrouperClientWs.mostRecentRequest,
32177           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
32178       assertFalse(GrouperClientWs.mostRecentRequest,
32179           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
32180       assertTrue(GrouperClientWs.mostRecentRequest,
32181           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
32182       assertTrue(GrouperClientWs.mostRecentRequest,
32183           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
32184       assertTrue(GrouperClientWs.mostRecentRequest,
32185           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
32186       assertTrue(GrouperClientWs.mostRecentRequest,
32187           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
32188       assertTrue(GrouperClientWs.mostRecentRequest,
32189           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
32190       assertTrue(GrouperClientWs.mostRecentRequest,
32191           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
32192       assertTrue(GrouperClientWs.mostRecentRequest,
32193           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
32194       assertTrue(GrouperClientWs.mostRecentRequest,
32195           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
32196       assertFalse(GrouperClientWs.mostRecentRequest,
32197           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
32198       assertFalse(GrouperClientWs.mostRecentRequest,
32199           GrouperClientWs.mostRecentRequest.contains("theValue"));
32200       assertFalse(GrouperClientWs.mostRecentRequest,
32201           GrouperClientWs.mostRecentRequest.contains(">123<"));
32202       assertFalse(GrouperClientWs.mostRecentRequest,
32203           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
32204       assertFalse(GrouperClientWs.mostRecentRequest,
32205           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
32206       assertTrue(GrouperClientWs.mostRecentRequest,
32207           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
32208       assertTrue(GrouperClientWs.mostRecentRequest,
32209           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
32210       assertTrue(GrouperClientWs.mostRecentRequest,
32211           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
32212       assertTrue(GrouperClientWs.mostRecentRequest,
32213           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
32214       assertTrue(GrouperClientWs.mostRecentRequest,
32215           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
32216       assertTrue(GrouperClientWs.mostRecentRequest,
32217           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
32218 
32219 
32220       // ######################################################
32221       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefLookups
32222 
32223       baos = new ByteArrayOutputStream();
32224       System.setOut(new PrintStream(baos));
32225 
32226       GrouperClient.main(GrouperClientUtils.splitTrim(
32227           "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --assignAssignOwnerNamesOfAttributeDefs=" + attributeDef.getName()
32228           ,
32229         " "));
32230 
32231       System.out.flush();
32232       output = new String(baos.toByteArray());
32233 
32234       System.setOut(systemOut);
32235 
32236       outputLines = GrouperClientUtils.splitTrim(output, "\n");
32237 
32238       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
32239       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
32240       pattern = Pattern
32241           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
32242 
32243       assertEquals(1, GrouperUtil.length(outputLines));
32244 
32245       outputLine = outputLines[0];
32246 
32247       matcher = pattern.matcher(outputLine);
32248 
32249       assertTrue(outputLine, matcher.matches());
32250       assertEquals(outputLine, "0", matcher.group(1));
32251       assertEquals(outputLine, "imm_mem_asgn", matcher.group(2));
32252       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
32253       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
32254       assertEquals(outputLine, "assign", matcher.group(5));
32255       assertEquals(outputLine, "123", matcher.group(6));
32256       assertEquals(outputLine, "T", matcher.group(7));
32257       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
32258 
32259       assertTrue(GrouperClientWs.mostRecentRequest,
32260           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
32261       assertTrue(GrouperClientWs.mostRecentRequest,
32262           !GrouperClientWs.mostRecentRequest.contains("actions"));
32263       assertTrue(GrouperClientWs.mostRecentRequest,
32264           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
32265       assertTrue(GrouperClientWs.mostRecentRequest,
32266           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
32267       assertTrue(GrouperClientWs.mostRecentRequest,
32268           !GrouperClientWs.mostRecentRequest.contains("enabled"));
32269       assertTrue(GrouperClientWs.mostRecentRequest,
32270           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
32271       assertTrue(GrouperClientWs.mostRecentRequest,
32272           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
32273       assertTrue(GrouperClientWs.mostRecentRequest,
32274           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
32275       assertTrue(GrouperClientWs.mostRecentRequest,
32276           !GrouperClientWs.mostRecentRequest.contains("params"));
32277       assertTrue(GrouperClientWs.mostRecentRequest,
32278           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
32279       assertTrue(GrouperClientWs.mostRecentRequest,
32280           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
32281       assertFalse(GrouperClientWs.mostRecentRequest,
32282           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
32283       assertFalse(GrouperClientWs.mostRecentRequest,
32284           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
32285       assertTrue(GrouperClientWs.mostRecentRequest,
32286           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
32287       assertTrue(GrouperClientWs.mostRecentRequest,
32288           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
32289       assertTrue(GrouperClientWs.mostRecentRequest,
32290           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
32291       assertTrue(GrouperClientWs.mostRecentRequest,
32292           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
32293       assertTrue(GrouperClientWs.mostRecentRequest,
32294           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
32295       assertTrue(GrouperClientWs.mostRecentRequest,
32296           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
32297       assertTrue(GrouperClientWs.mostRecentRequest,
32298           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
32299       assertFalse(GrouperClientWs.mostRecentRequest,
32300           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
32301       assertFalse(GrouperClientWs.mostRecentRequest,
32302           GrouperClientWs.mostRecentRequest.contains("theValue"));
32303       assertFalse(GrouperClientWs.mostRecentRequest,
32304           GrouperClientWs.mostRecentRequest.contains(">123<"));
32305       assertFalse(GrouperClientWs.mostRecentRequest,
32306           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
32307       assertFalse(GrouperClientWs.mostRecentRequest,
32308           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
32309       assertTrue(GrouperClientWs.mostRecentRequest,
32310           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
32311       assertTrue(GrouperClientWs.mostRecentRequest,
32312           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
32313       assertTrue(GrouperClientWs.mostRecentRequest,
32314           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
32315       assertTrue(GrouperClientWs.mostRecentRequest,
32316           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
32317       assertTrue(GrouperClientWs.mostRecentRequest,
32318           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
32319       assertTrue(GrouperClientWs.mostRecentRequest,
32320           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
32321 
32322 
32323 
32324       // ######################################################
32325       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefLookups with wrong name
32326 
32327       baos = new ByteArrayOutputStream();
32328       System.setOut(new PrintStream(baos));
32329 
32330       try {
32331         GrouperClient.main(GrouperClientUtils.splitTrim(
32332             "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --assignAssignOwnerNamesOfAttributeDefs=1" + attributeDef.getName()
32333             ,
32334           " "));
32335 
32336         System.out.flush();
32337         output = new String(baos.toByteArray());
32338 
32339         System.setOut(systemOut);
32340 
32341         outputLines = GrouperClientUtils.splitTrim(output, "\n");
32342 
32343         // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
32344         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
32345         pattern = Pattern
32346             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
32347 
32348         assertEquals(0, GrouperUtil.length(outputLines));
32349 
32350         fail("shouldnt get here");
32351       } catch (Exception e) {
32352         //good
32353       } finally {
32354         System.setOut(systemOut);
32355       }
32356 
32357       assertTrue(GrouperClientWs.mostRecentRequest,
32358           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
32359       assertTrue(GrouperClientWs.mostRecentRequest,
32360           !GrouperClientWs.mostRecentRequest.contains("actions"));
32361       assertTrue(GrouperClientWs.mostRecentRequest,
32362           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
32363       assertTrue(GrouperClientWs.mostRecentRequest,
32364           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
32365       assertTrue(GrouperClientWs.mostRecentRequest,
32366           !GrouperClientWs.mostRecentRequest.contains("enabled"));
32367       assertTrue(GrouperClientWs.mostRecentRequest,
32368           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
32369       assertTrue(GrouperClientWs.mostRecentRequest,
32370           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
32371       assertTrue(GrouperClientWs.mostRecentRequest,
32372           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
32373       assertTrue(GrouperClientWs.mostRecentRequest,
32374           !GrouperClientWs.mostRecentRequest.contains("params"));
32375       assertTrue(GrouperClientWs.mostRecentRequest,
32376           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
32377       assertTrue(GrouperClientWs.mostRecentRequest,
32378           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
32379       assertFalse(GrouperClientWs.mostRecentRequest,
32380           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
32381       assertFalse(GrouperClientWs.mostRecentRequest,
32382           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
32383       assertTrue(GrouperClientWs.mostRecentRequest,
32384           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
32385       assertTrue(GrouperClientWs.mostRecentRequest,
32386           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
32387       assertTrue(GrouperClientWs.mostRecentRequest,
32388           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
32389       assertTrue(GrouperClientWs.mostRecentRequest,
32390           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
32391       assertTrue(GrouperClientWs.mostRecentRequest,
32392           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
32393       assertTrue(GrouperClientWs.mostRecentRequest,
32394           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
32395       assertTrue(GrouperClientWs.mostRecentRequest,
32396           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
32397       assertFalse(GrouperClientWs.mostRecentRequest,
32398           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
32399       assertFalse(GrouperClientWs.mostRecentRequest,
32400           GrouperClientWs.mostRecentRequest.contains("theValue"));
32401       assertFalse(GrouperClientWs.mostRecentRequest,
32402           GrouperClientWs.mostRecentRequest.contains(">123<"));
32403       assertFalse(GrouperClientWs.mostRecentRequest,
32404           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
32405       assertFalse(GrouperClientWs.mostRecentRequest,
32406           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
32407       assertTrue(GrouperClientWs.mostRecentRequest,
32408           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
32409       assertTrue(GrouperClientWs.mostRecentRequest,
32410           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
32411       assertTrue(GrouperClientWs.mostRecentRequest,
32412           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
32413       assertTrue(GrouperClientWs.mostRecentRequest,
32414           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
32415       assertTrue(GrouperClientWs.mostRecentRequest,
32416           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
32417       assertTrue(GrouperClientWs.mostRecentRequest,
32418           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
32419 
32420 
32421       // ######################################################
32422       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefLookups
32423 
32424       baos = new ByteArrayOutputStream();
32425       System.setOut(new PrintStream(baos));
32426 
32427       GrouperClient.main(GrouperClientUtils.splitTrim(
32428           "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --assignAssignOwnerUuidsOfAttributeDefs=" + attributeDef.getId()
32429           ,
32430         " "));
32431 
32432       System.out.flush();
32433       output = new String(baos.toByteArray());
32434 
32435       System.setOut(systemOut);
32436 
32437       outputLines = GrouperClientUtils.splitTrim(output, "\n");
32438 
32439       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
32440       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
32441       pattern = Pattern
32442           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
32443 
32444       assertEquals(1, GrouperUtil.length(outputLines));
32445 
32446       outputLine = outputLines[0];
32447 
32448       matcher = pattern.matcher(outputLine);
32449 
32450       assertTrue(outputLine, matcher.matches());
32451       assertEquals(outputLine, "0", matcher.group(1));
32452       assertEquals(outputLine, "imm_mem_asgn", matcher.group(2));
32453       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
32454       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
32455       assertEquals(outputLine, "assign", matcher.group(5));
32456       assertEquals(outputLine, "123", matcher.group(6));
32457       assertEquals(outputLine, "T", matcher.group(7));
32458       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
32459 
32460       assertTrue(GrouperClientWs.mostRecentRequest,
32461           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
32462       assertTrue(GrouperClientWs.mostRecentRequest,
32463           !GrouperClientWs.mostRecentRequest.contains("actions"));
32464       assertTrue(GrouperClientWs.mostRecentRequest,
32465           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
32466       assertTrue(GrouperClientWs.mostRecentRequest,
32467           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
32468       assertTrue(GrouperClientWs.mostRecentRequest,
32469           !GrouperClientWs.mostRecentRequest.contains("enabled"));
32470       assertTrue(GrouperClientWs.mostRecentRequest,
32471           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
32472       assertTrue(GrouperClientWs.mostRecentRequest,
32473           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
32474       assertTrue(GrouperClientWs.mostRecentRequest,
32475           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
32476       assertTrue(GrouperClientWs.mostRecentRequest,
32477           !GrouperClientWs.mostRecentRequest.contains("params"));
32478       assertTrue(GrouperClientWs.mostRecentRequest,
32479           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
32480       assertTrue(GrouperClientWs.mostRecentRequest,
32481           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
32482       assertFalse(GrouperClientWs.mostRecentRequest,
32483           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
32484       assertTrue(GrouperClientWs.mostRecentRequest,
32485           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
32486       assertTrue(GrouperClientWs.mostRecentRequest,
32487           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
32488       assertTrue(GrouperClientWs.mostRecentRequest,
32489           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
32490       assertTrue(GrouperClientWs.mostRecentRequest,
32491           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
32492       assertTrue(GrouperClientWs.mostRecentRequest,
32493           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
32494       assertTrue(GrouperClientWs.mostRecentRequest,
32495           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
32496       assertTrue(GrouperClientWs.mostRecentRequest,
32497           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
32498       assertTrue(GrouperClientWs.mostRecentRequest,
32499           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
32500       assertFalse(GrouperClientWs.mostRecentRequest,
32501           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
32502       assertFalse(GrouperClientWs.mostRecentRequest,
32503           GrouperClientWs.mostRecentRequest.contains("theValue"));
32504       assertFalse(GrouperClientWs.mostRecentRequest,
32505           GrouperClientWs.mostRecentRequest.contains(">123<"));
32506       assertFalse(GrouperClientWs.mostRecentRequest,
32507           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
32508       assertFalse(GrouperClientWs.mostRecentRequest,
32509           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
32510       assertTrue(GrouperClientWs.mostRecentRequest,
32511           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
32512       assertTrue(GrouperClientWs.mostRecentRequest,
32513           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
32514       assertTrue(GrouperClientWs.mostRecentRequest,
32515           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
32516       assertTrue(GrouperClientWs.mostRecentRequest,
32517           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
32518       assertTrue(GrouperClientWs.mostRecentRequest,
32519           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
32520       assertTrue(GrouperClientWs.mostRecentRequest,
32521           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
32522 
32523 
32524       // ######################################################
32525       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefLookups
32526 
32527       baos = new ByteArrayOutputStream();
32528       System.setOut(new PrintStream(baos));
32529 
32530       GrouperClient.main(GrouperClientUtils.splitTrim(
32531           "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --assignAssignOwnerUuidsOfAttributeDefs=" + attributeDef.getId()
32532           ,
32533         " "));
32534 
32535       System.out.flush();
32536       output = new String(baos.toByteArray());
32537 
32538       System.setOut(systemOut);
32539 
32540       outputLines = GrouperClientUtils.splitTrim(output, "\n");
32541 
32542       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
32543       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
32544       pattern = Pattern
32545           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
32546 
32547       assertEquals(1, GrouperUtil.length(outputLines));
32548 
32549       outputLine = outputLines[0];
32550 
32551       matcher = pattern.matcher(outputLine);
32552 
32553       assertTrue(outputLine, matcher.matches());
32554       assertEquals(outputLine, "0", matcher.group(1));
32555       assertEquals(outputLine, "imm_mem_asgn", matcher.group(2));
32556       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
32557       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
32558       assertEquals(outputLine, "assign", matcher.group(5));
32559       assertEquals(outputLine, "123", matcher.group(6));
32560       assertEquals(outputLine, "T", matcher.group(7));
32561       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
32562 
32563       assertTrue(GrouperClientWs.mostRecentRequest,
32564           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
32565       assertTrue(GrouperClientWs.mostRecentRequest,
32566           !GrouperClientWs.mostRecentRequest.contains("actions"));
32567       assertTrue(GrouperClientWs.mostRecentRequest,
32568           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
32569       assertTrue(GrouperClientWs.mostRecentRequest,
32570           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
32571       assertTrue(GrouperClientWs.mostRecentRequest,
32572           !GrouperClientWs.mostRecentRequest.contains("enabled"));
32573       assertTrue(GrouperClientWs.mostRecentRequest,
32574           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
32575       assertTrue(GrouperClientWs.mostRecentRequest,
32576           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
32577       assertTrue(GrouperClientWs.mostRecentRequest,
32578           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
32579       assertTrue(GrouperClientWs.mostRecentRequest,
32580           !GrouperClientWs.mostRecentRequest.contains("params"));
32581       assertTrue(GrouperClientWs.mostRecentRequest,
32582           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
32583       assertTrue(GrouperClientWs.mostRecentRequest,
32584           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
32585       assertFalse(GrouperClientWs.mostRecentRequest,
32586           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
32587       assertTrue(GrouperClientWs.mostRecentRequest,
32588           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
32589       assertTrue(GrouperClientWs.mostRecentRequest,
32590           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
32591       assertTrue(GrouperClientWs.mostRecentRequest,
32592           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
32593       assertTrue(GrouperClientWs.mostRecentRequest,
32594           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
32595       assertTrue(GrouperClientWs.mostRecentRequest,
32596           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
32597       assertTrue(GrouperClientWs.mostRecentRequest,
32598           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
32599       assertTrue(GrouperClientWs.mostRecentRequest,
32600           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
32601       assertTrue(GrouperClientWs.mostRecentRequest,
32602           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
32603       assertFalse(GrouperClientWs.mostRecentRequest,
32604           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
32605       assertFalse(GrouperClientWs.mostRecentRequest,
32606           GrouperClientWs.mostRecentRequest.contains("theValue"));
32607       assertFalse(GrouperClientWs.mostRecentRequest,
32608           GrouperClientWs.mostRecentRequest.contains(">123<"));
32609       assertFalse(GrouperClientWs.mostRecentRequest,
32610           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
32611       assertFalse(GrouperClientWs.mostRecentRequest,
32612           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
32613       assertTrue(GrouperClientWs.mostRecentRequest,
32614           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
32615       assertTrue(GrouperClientWs.mostRecentRequest,
32616           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
32617       assertTrue(GrouperClientWs.mostRecentRequest,
32618           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
32619       assertTrue(GrouperClientWs.mostRecentRequest,
32620           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
32621       assertTrue(GrouperClientWs.mostRecentRequest,
32622           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
32623       assertTrue(GrouperClientWs.mostRecentRequest,
32624           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
32625 
32626 
32627 
32628       // ######################################################
32629       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefLookups
32630 
32631       baos = new ByteArrayOutputStream();
32632       System.setOut(new PrintStream(baos));
32633 
32634       try {
32635         GrouperClient.main(GrouperClientUtils.splitTrim(
32636             "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --assignAssignOwnerUuidsOfAttributeDefs=1" + attributeDef.getId()
32637             ,
32638           " "));
32639 
32640         System.out.flush();
32641         output = new String(baos.toByteArray());
32642 
32643         System.setOut(systemOut);
32644 
32645         outputLines = GrouperClientUtils.splitTrim(output, "\n");
32646 
32647         // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
32648         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
32649         pattern = Pattern
32650             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
32651 
32652         assertEquals(0, GrouperUtil.length(outputLines));
32653         fail("Shouldnt get here");
32654       } catch (Exception e) {
32655         //good
32656       } finally {
32657 
32658         System.setOut(systemOut);
32659 
32660       }
32661 
32662       assertTrue(GrouperClientWs.mostRecentRequest,
32663           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
32664       assertTrue(GrouperClientWs.mostRecentRequest,
32665           !GrouperClientWs.mostRecentRequest.contains("actions"));
32666       assertTrue(GrouperClientWs.mostRecentRequest,
32667           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
32668       assertTrue(GrouperClientWs.mostRecentRequest,
32669           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
32670       assertTrue(GrouperClientWs.mostRecentRequest,
32671           !GrouperClientWs.mostRecentRequest.contains("enabled"));
32672       assertTrue(GrouperClientWs.mostRecentRequest,
32673           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
32674       assertTrue(GrouperClientWs.mostRecentRequest,
32675           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
32676       assertTrue(GrouperClientWs.mostRecentRequest,
32677           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
32678       assertTrue(GrouperClientWs.mostRecentRequest,
32679           !GrouperClientWs.mostRecentRequest.contains("params"));
32680       assertTrue(GrouperClientWs.mostRecentRequest,
32681           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
32682       assertTrue(GrouperClientWs.mostRecentRequest,
32683           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
32684       assertFalse(GrouperClientWs.mostRecentRequest,
32685           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
32686       assertTrue(GrouperClientWs.mostRecentRequest,
32687           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
32688       assertTrue(GrouperClientWs.mostRecentRequest,
32689           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
32690       assertTrue(GrouperClientWs.mostRecentRequest,
32691           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
32692       assertTrue(GrouperClientWs.mostRecentRequest,
32693           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
32694       assertTrue(GrouperClientWs.mostRecentRequest,
32695           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
32696       assertTrue(GrouperClientWs.mostRecentRequest,
32697           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
32698       assertTrue(GrouperClientWs.mostRecentRequest,
32699           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
32700       assertTrue(GrouperClientWs.mostRecentRequest,
32701           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
32702       assertFalse(GrouperClientWs.mostRecentRequest,
32703           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
32704       assertFalse(GrouperClientWs.mostRecentRequest,
32705           GrouperClientWs.mostRecentRequest.contains("theValue"));
32706       assertFalse(GrouperClientWs.mostRecentRequest,
32707           GrouperClientWs.mostRecentRequest.contains(">123<"));
32708       assertFalse(GrouperClientWs.mostRecentRequest,
32709           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
32710       assertFalse(GrouperClientWs.mostRecentRequest,
32711           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
32712       assertTrue(GrouperClientWs.mostRecentRequest,
32713           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
32714       assertTrue(GrouperClientWs.mostRecentRequest,
32715           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
32716       assertTrue(GrouperClientWs.mostRecentRequest,
32717           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
32718       assertTrue(GrouperClientWs.mostRecentRequest,
32719           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
32720       assertTrue(GrouperClientWs.mostRecentRequest,
32721           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
32722       assertTrue(GrouperClientWs.mostRecentRequest,
32723           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
32724 
32725 
32726       // ######################################################
32727       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups
32728 
32729       baos = new ByteArrayOutputStream();
32730       System.setOut(new PrintStream(baos));
32731 
32732       GrouperClient.main(GrouperClientUtils.splitTrim(
32733           "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --assignAssignOwnerNamesOfAttributeDefNames=" + attributeDefName.getName()
32734           ,
32735         " "));
32736 
32737       System.out.flush();
32738       output = new String(baos.toByteArray());
32739 
32740       System.setOut(systemOut);
32741 
32742       outputLines = GrouperClientUtils.splitTrim(output, "\n");
32743 
32744       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
32745       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
32746       pattern = Pattern
32747           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
32748 
32749       assertEquals(1, GrouperUtil.length(outputLines));
32750 
32751       outputLine = outputLines[0];
32752 
32753       matcher = pattern.matcher(outputLine);
32754 
32755       assertTrue(outputLine, matcher.matches());
32756       assertEquals(outputLine, "0", matcher.group(1));
32757       assertEquals(outputLine, "imm_mem_asgn", matcher.group(2));
32758       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
32759       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
32760       assertEquals(outputLine, "assign", matcher.group(5));
32761       assertEquals(outputLine, "123", matcher.group(6));
32762       assertEquals(outputLine, "T", matcher.group(7));
32763       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
32764 
32765       assertTrue(GrouperClientWs.mostRecentRequest,
32766           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
32767       assertTrue(GrouperClientWs.mostRecentRequest,
32768           !GrouperClientWs.mostRecentRequest.contains("actions"));
32769       assertTrue(GrouperClientWs.mostRecentRequest,
32770           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
32771       assertTrue(GrouperClientWs.mostRecentRequest,
32772           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
32773       assertTrue(GrouperClientWs.mostRecentRequest,
32774           !GrouperClientWs.mostRecentRequest.contains("enabled"));
32775       assertTrue(GrouperClientWs.mostRecentRequest,
32776           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
32777       assertTrue(GrouperClientWs.mostRecentRequest,
32778           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
32779       assertTrue(GrouperClientWs.mostRecentRequest,
32780           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
32781       assertTrue(GrouperClientWs.mostRecentRequest,
32782           !GrouperClientWs.mostRecentRequest.contains("params"));
32783       assertTrue(GrouperClientWs.mostRecentRequest,
32784           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
32785       assertTrue(GrouperClientWs.mostRecentRequest,
32786           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
32787       assertFalse(GrouperClientWs.mostRecentRequest,
32788           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
32789       assertFalse(GrouperClientWs.mostRecentRequest,
32790           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
32791       assertTrue(GrouperClientWs.mostRecentRequest,
32792           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
32793       assertTrue(GrouperClientWs.mostRecentRequest,
32794           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
32795       assertTrue(GrouperClientWs.mostRecentRequest,
32796           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
32797       assertTrue(GrouperClientWs.mostRecentRequest,
32798           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
32799       assertTrue(GrouperClientWs.mostRecentRequest,
32800           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
32801       assertTrue(GrouperClientWs.mostRecentRequest,
32802           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
32803       assertTrue(GrouperClientWs.mostRecentRequest,
32804           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
32805       assertFalse(GrouperClientWs.mostRecentRequest,
32806           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
32807       assertFalse(GrouperClientWs.mostRecentRequest,
32808           GrouperClientWs.mostRecentRequest.contains("theValue"));
32809       assertFalse(GrouperClientWs.mostRecentRequest,
32810           GrouperClientWs.mostRecentRequest.contains(">123<"));
32811       assertFalse(GrouperClientWs.mostRecentRequest,
32812           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
32813       assertFalse(GrouperClientWs.mostRecentRequest,
32814           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
32815       assertTrue(GrouperClientWs.mostRecentRequest,
32816           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
32817       assertTrue(GrouperClientWs.mostRecentRequest,
32818           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
32819       assertTrue(GrouperClientWs.mostRecentRequest,
32820           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
32821       assertTrue(GrouperClientWs.mostRecentRequest,
32822           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
32823 
32824 
32825 
32826       // ######################################################
32827       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups
32828 
32829       baos = new ByteArrayOutputStream();
32830       System.setOut(new PrintStream(baos));
32831 
32832       try {
32833         GrouperClient.main(GrouperClientUtils.splitTrim(
32834             "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --assignAssignOwnerNamesOfAttributeDefNames=1" + attributeDefName.getName()
32835             ,
32836           " "));
32837 
32838         System.out.flush();
32839         output = new String(baos.toByteArray());
32840 
32841         System.setOut(systemOut);
32842 
32843         outputLines = GrouperClientUtils.splitTrim(output, "\n");
32844 
32845         // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
32846         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
32847         pattern = Pattern
32848             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
32849 
32850         assertEquals(0, GrouperUtil.length(outputLines));
32851         fail("Shouldnt get here");
32852 
32853       } catch (Exception e) {
32854         //ok
32855       } finally {
32856 
32857         System.setOut(systemOut);
32858 
32859       }
32860 
32861       assertTrue(GrouperClientWs.mostRecentRequest,
32862           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
32863       assertTrue(GrouperClientWs.mostRecentRequest,
32864           !GrouperClientWs.mostRecentRequest.contains("actions"));
32865       assertTrue(GrouperClientWs.mostRecentRequest,
32866           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
32867       assertTrue(GrouperClientWs.mostRecentRequest,
32868           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
32869       assertTrue(GrouperClientWs.mostRecentRequest,
32870           !GrouperClientWs.mostRecentRequest.contains("enabled"));
32871       assertTrue(GrouperClientWs.mostRecentRequest,
32872           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
32873       assertTrue(GrouperClientWs.mostRecentRequest,
32874           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
32875       assertTrue(GrouperClientWs.mostRecentRequest,
32876           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
32877       assertTrue(GrouperClientWs.mostRecentRequest,
32878           !GrouperClientWs.mostRecentRequest.contains("params"));
32879       assertTrue(GrouperClientWs.mostRecentRequest,
32880           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
32881       assertTrue(GrouperClientWs.mostRecentRequest,
32882           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
32883       assertFalse(GrouperClientWs.mostRecentRequest,
32884           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
32885       assertFalse(GrouperClientWs.mostRecentRequest,
32886           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
32887       assertTrue(GrouperClientWs.mostRecentRequest,
32888           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
32889       assertTrue(GrouperClientWs.mostRecentRequest,
32890           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
32891       assertTrue(GrouperClientWs.mostRecentRequest,
32892           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
32893       assertTrue(GrouperClientWs.mostRecentRequest,
32894           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
32895       assertTrue(GrouperClientWs.mostRecentRequest,
32896           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
32897       assertTrue(GrouperClientWs.mostRecentRequest,
32898           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
32899       assertTrue(GrouperClientWs.mostRecentRequest,
32900           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
32901       assertFalse(GrouperClientWs.mostRecentRequest,
32902           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
32903       assertFalse(GrouperClientWs.mostRecentRequest,
32904           GrouperClientWs.mostRecentRequest.contains("theValue"));
32905       assertFalse(GrouperClientWs.mostRecentRequest,
32906           GrouperClientWs.mostRecentRequest.contains(">123<"));
32907       assertFalse(GrouperClientWs.mostRecentRequest,
32908           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
32909       assertFalse(GrouperClientWs.mostRecentRequest,
32910           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
32911       assertTrue(GrouperClientWs.mostRecentRequest,
32912           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
32913       assertTrue(GrouperClientWs.mostRecentRequest,
32914           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
32915       assertTrue(GrouperClientWs.mostRecentRequest,
32916           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
32917       assertTrue(GrouperClientWs.mostRecentRequest,
32918           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
32919 
32920 
32921       // ######################################################
32922       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups
32923 
32924       baos = new ByteArrayOutputStream();
32925       System.setOut(new PrintStream(baos));
32926 
32927       GrouperClient.main(GrouperClientUtils.splitTrim(
32928           "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
32929           ,
32930         " "));
32931 
32932       System.out.flush();
32933       output = new String(baos.toByteArray());
32934 
32935       System.setOut(systemOut);
32936 
32937       outputLines = GrouperClientUtils.splitTrim(output, "\n");
32938 
32939       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
32940       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
32941       pattern = Pattern
32942           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
32943 
32944       assertEquals(1, GrouperUtil.length(outputLines));
32945 
32946       outputLine = outputLines[0];
32947 
32948       matcher = pattern.matcher(outputLine);
32949 
32950       assertTrue(outputLine, matcher.matches());
32951       assertEquals(outputLine, "0", matcher.group(1));
32952       assertEquals(outputLine, "imm_mem_asgn", matcher.group(2));
32953       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
32954       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
32955       assertEquals(outputLine, "assign", matcher.group(5));
32956       assertEquals(outputLine, "123", matcher.group(6));
32957       assertEquals(outputLine, "T", matcher.group(7));
32958       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
32959 
32960       assertTrue(GrouperClientWs.mostRecentRequest,
32961           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
32962       assertTrue(GrouperClientWs.mostRecentRequest,
32963           !GrouperClientWs.mostRecentRequest.contains("actions"));
32964       assertTrue(GrouperClientWs.mostRecentRequest,
32965           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
32966       assertTrue(GrouperClientWs.mostRecentRequest,
32967           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
32968       assertTrue(GrouperClientWs.mostRecentRequest,
32969           !GrouperClientWs.mostRecentRequest.contains("enabled"));
32970       assertTrue(GrouperClientWs.mostRecentRequest,
32971           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
32972       assertTrue(GrouperClientWs.mostRecentRequest,
32973           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
32974       assertTrue(GrouperClientWs.mostRecentRequest,
32975           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
32976       assertTrue(GrouperClientWs.mostRecentRequest,
32977           !GrouperClientWs.mostRecentRequest.contains("params"));
32978       assertTrue(GrouperClientWs.mostRecentRequest,
32979           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
32980       assertTrue(GrouperClientWs.mostRecentRequest,
32981           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
32982       assertFalse(GrouperClientWs.mostRecentRequest,
32983           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
32984       assertTrue(GrouperClientWs.mostRecentRequest,
32985           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
32986       assertTrue(GrouperClientWs.mostRecentRequest,
32987           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
32988       assertTrue(GrouperClientWs.mostRecentRequest,
32989           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
32990       assertTrue(GrouperClientWs.mostRecentRequest,
32991           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
32992       assertTrue(GrouperClientWs.mostRecentRequest,
32993           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
32994       assertTrue(GrouperClientWs.mostRecentRequest,
32995           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
32996       assertTrue(GrouperClientWs.mostRecentRequest,
32997           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
32998       assertTrue(GrouperClientWs.mostRecentRequest,
32999           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
33000       assertFalse(GrouperClientWs.mostRecentRequest,
33001           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
33002       assertFalse(GrouperClientWs.mostRecentRequest,
33003           GrouperClientWs.mostRecentRequest.contains("theValue"));
33004       assertFalse(GrouperClientWs.mostRecentRequest,
33005           GrouperClientWs.mostRecentRequest.contains(">123<"));
33006       assertFalse(GrouperClientWs.mostRecentRequest,
33007           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
33008       assertFalse(GrouperClientWs.mostRecentRequest,
33009           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
33010       assertTrue(GrouperClientWs.mostRecentRequest,
33011           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
33012       assertTrue(GrouperClientWs.mostRecentRequest,
33013           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
33014       assertTrue(GrouperClientWs.mostRecentRequest,
33015           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
33016       assertTrue(GrouperClientWs.mostRecentRequest,
33017           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
33018 
33019 
33020 
33021       // ######################################################
33022       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups wrong name
33023 
33024       baos = new ByteArrayOutputStream();
33025       System.setOut(new PrintStream(baos));
33026 
33027       try {
33028         GrouperClient.main(GrouperClientUtils.splitTrim(
33029             "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --assignAssignOwnerUuidsOfAttributeDefNames=1" + attributeDefName.getId()
33030             ,
33031           " "));
33032 
33033         System.out.flush();
33034         output = new String(baos.toByteArray());
33035 
33036         System.setOut(systemOut);
33037 
33038         outputLines = GrouperClientUtils.splitTrim(output, "\n");
33039 
33040         // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
33041         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
33042         pattern = Pattern
33043             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
33044 
33045         assertEquals(1, GrouperUtil.length(outputLines));
33046         fail("Shouldnt get here");
33047       } catch (Exception e) {
33048         //good
33049       } finally {
33050 
33051         System.setOut(systemOut);
33052 
33053       }
33054 
33055       assertTrue(GrouperClientWs.mostRecentRequest,
33056           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
33057       assertTrue(GrouperClientWs.mostRecentRequest,
33058           !GrouperClientWs.mostRecentRequest.contains("actions"));
33059       assertTrue(GrouperClientWs.mostRecentRequest,
33060           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
33061       assertTrue(GrouperClientWs.mostRecentRequest,
33062           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
33063       assertTrue(GrouperClientWs.mostRecentRequest,
33064           !GrouperClientWs.mostRecentRequest.contains("enabled"));
33065       assertTrue(GrouperClientWs.mostRecentRequest,
33066           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
33067       assertTrue(GrouperClientWs.mostRecentRequest,
33068           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
33069       assertTrue(GrouperClientWs.mostRecentRequest,
33070           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
33071       assertTrue(GrouperClientWs.mostRecentRequest,
33072           !GrouperClientWs.mostRecentRequest.contains("params"));
33073       assertTrue(GrouperClientWs.mostRecentRequest,
33074           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
33075       assertTrue(GrouperClientWs.mostRecentRequest,
33076           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
33077       assertFalse(GrouperClientWs.mostRecentRequest,
33078           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
33079       assertTrue(GrouperClientWs.mostRecentRequest,
33080           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
33081       assertTrue(GrouperClientWs.mostRecentRequest,
33082           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
33083       assertTrue(GrouperClientWs.mostRecentRequest,
33084           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
33085       assertTrue(GrouperClientWs.mostRecentRequest,
33086           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
33087       assertTrue(GrouperClientWs.mostRecentRequest,
33088           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
33089       assertTrue(GrouperClientWs.mostRecentRequest,
33090           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
33091       assertTrue(GrouperClientWs.mostRecentRequest,
33092           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
33093       assertTrue(GrouperClientWs.mostRecentRequest,
33094           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
33095       assertFalse(GrouperClientWs.mostRecentRequest,
33096           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
33097       assertFalse(GrouperClientWs.mostRecentRequest,
33098           GrouperClientWs.mostRecentRequest.contains("theValue"));
33099       assertFalse(GrouperClientWs.mostRecentRequest,
33100           GrouperClientWs.mostRecentRequest.contains(">123<"));
33101       assertFalse(GrouperClientWs.mostRecentRequest,
33102           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
33103       assertFalse(GrouperClientWs.mostRecentRequest,
33104           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
33105       assertTrue(GrouperClientWs.mostRecentRequest,
33106           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
33107       assertTrue(GrouperClientWs.mostRecentRequest,
33108           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
33109       assertTrue(GrouperClientWs.mostRecentRequest,
33110           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
33111       assertTrue(GrouperClientWs.mostRecentRequest,
33112           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
33113 
33114 
33115       // ######################################################
33116       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups
33117 
33118       baos = new ByteArrayOutputStream();
33119       System.setOut(new PrintStream(baos));
33120 
33121       GrouperClient.main(GrouperClientUtils.splitTrim(
33122           "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
33123           + " --assignAssignOwnerActions=assign",
33124         " "));
33125 
33126       System.out.flush();
33127       output = new String(baos.toByteArray());
33128 
33129       System.setOut(systemOut);
33130 
33131       outputLines = GrouperClientUtils.splitTrim(output, "\n");
33132 
33133       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
33134       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
33135       pattern = Pattern
33136           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
33137 
33138       assertEquals(1, GrouperUtil.length(outputLines));
33139 
33140       outputLine = outputLines[0];
33141 
33142       matcher = pattern.matcher(outputLine);
33143 
33144       assertTrue(outputLine, matcher.matches());
33145       assertEquals(outputLine, "0", matcher.group(1));
33146       assertEquals(outputLine, "imm_mem_asgn", matcher.group(2));
33147       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
33148       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
33149       assertEquals(outputLine, "assign", matcher.group(5));
33150       assertEquals(outputLine, "123", matcher.group(6));
33151       assertEquals(outputLine, "T", matcher.group(7));
33152       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
33153 
33154       assertTrue(GrouperClientWs.mostRecentRequest,
33155           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
33156       assertTrue(GrouperClientWs.mostRecentRequest,
33157           !GrouperClientWs.mostRecentRequest.contains("<actions>"));
33158       assertTrue(GrouperClientWs.mostRecentRequest,
33159           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
33160       assertTrue(GrouperClientWs.mostRecentRequest,
33161           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
33162       assertTrue(GrouperClientWs.mostRecentRequest,
33163           !GrouperClientWs.mostRecentRequest.contains("enabled"));
33164       assertTrue(GrouperClientWs.mostRecentRequest,
33165           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
33166       assertTrue(GrouperClientWs.mostRecentRequest,
33167           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
33168       assertTrue(GrouperClientWs.mostRecentRequest,
33169           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
33170       assertTrue(GrouperClientWs.mostRecentRequest,
33171           !GrouperClientWs.mostRecentRequest.contains("params"));
33172       assertTrue(GrouperClientWs.mostRecentRequest,
33173           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
33174       assertTrue(GrouperClientWs.mostRecentRequest,
33175           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
33176       assertFalse(GrouperClientWs.mostRecentRequest,
33177           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
33178       assertTrue(GrouperClientWs.mostRecentRequest,
33179           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
33180       assertTrue(GrouperClientWs.mostRecentRequest,
33181           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
33182       assertTrue(GrouperClientWs.mostRecentRequest,
33183           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
33184       assertTrue(GrouperClientWs.mostRecentRequest,
33185           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
33186       assertTrue(GrouperClientWs.mostRecentRequest,
33187           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
33188       assertTrue(GrouperClientWs.mostRecentRequest,
33189           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
33190       assertTrue(GrouperClientWs.mostRecentRequest,
33191           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
33192       assertTrue(GrouperClientWs.mostRecentRequest,
33193           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
33194       assertFalse(GrouperClientWs.mostRecentRequest,
33195           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
33196       assertFalse(GrouperClientWs.mostRecentRequest,
33197           GrouperClientWs.mostRecentRequest.contains("theValue"));
33198       assertFalse(GrouperClientWs.mostRecentRequest,
33199           GrouperClientWs.mostRecentRequest.contains(">123<"));
33200       assertFalse(GrouperClientWs.mostRecentRequest,
33201           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
33202       assertFalse(GrouperClientWs.mostRecentRequest,
33203           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
33204       assertTrue(GrouperClientWs.mostRecentRequest,
33205           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
33206       assertTrue(GrouperClientWs.mostRecentRequest,
33207           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
33208       assertTrue(GrouperClientWs.mostRecentRequest,
33209           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
33210       assertTrue(GrouperClientWs.mostRecentRequest,
33211           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
33212 
33213 
33214       // ######################################################
33215       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups wrong action
33216 
33217       baos = new ByteArrayOutputStream();
33218       System.setOut(new PrintStream(baos));
33219 
33220       GrouperClient.main(GrouperClientUtils.splitTrim(
33221           "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
33222           + " --assignAssignOwnerActions=assign2",
33223         " "));
33224 
33225       System.out.flush();
33226       output = new String(baos.toByteArray());
33227 
33228       System.setOut(systemOut);
33229 
33230       outputLines = GrouperClientUtils.splitTrim(output, "\n");
33231 
33232       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
33233       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
33234       pattern = Pattern
33235           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
33236 
33237       assertEquals(0, GrouperUtil.length(outputLines));
33238 
33239       assertTrue(GrouperClientWs.mostRecentRequest,
33240           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
33241       assertTrue(GrouperClientWs.mostRecentRequest,
33242           !GrouperClientWs.mostRecentRequest.contains("<actions>"));
33243       assertTrue(GrouperClientWs.mostRecentRequest,
33244           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
33245       assertTrue(GrouperClientWs.mostRecentRequest,
33246           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
33247       assertTrue(GrouperClientWs.mostRecentRequest,
33248           !GrouperClientWs.mostRecentRequest.contains("enabled"));
33249       assertTrue(GrouperClientWs.mostRecentRequest,
33250           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
33251       assertTrue(GrouperClientWs.mostRecentRequest,
33252           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
33253       assertTrue(GrouperClientWs.mostRecentRequest,
33254           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
33255       assertTrue(GrouperClientWs.mostRecentRequest,
33256           !GrouperClientWs.mostRecentRequest.contains("params"));
33257       assertTrue(GrouperClientWs.mostRecentRequest,
33258           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
33259       assertTrue(GrouperClientWs.mostRecentRequest,
33260           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
33261       assertFalse(GrouperClientWs.mostRecentRequest,
33262           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
33263       assertTrue(GrouperClientWs.mostRecentRequest,
33264           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
33265       assertTrue(GrouperClientWs.mostRecentRequest,
33266           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
33267       assertTrue(GrouperClientWs.mostRecentRequest,
33268           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
33269       assertTrue(GrouperClientWs.mostRecentRequest,
33270           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
33271       assertTrue(GrouperClientWs.mostRecentRequest,
33272           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
33273       assertTrue(GrouperClientWs.mostRecentRequest,
33274           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
33275       assertTrue(GrouperClientWs.mostRecentRequest,
33276           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
33277       assertTrue(GrouperClientWs.mostRecentRequest,
33278           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
33279       assertFalse(GrouperClientWs.mostRecentRequest,
33280           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
33281       assertFalse(GrouperClientWs.mostRecentRequest,
33282           GrouperClientWs.mostRecentRequest.contains("theValue"));
33283       assertFalse(GrouperClientWs.mostRecentRequest,
33284           GrouperClientWs.mostRecentRequest.contains(">123<"));
33285       assertFalse(GrouperClientWs.mostRecentRequest,
33286           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
33287       assertFalse(GrouperClientWs.mostRecentRequest,
33288           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
33289       assertTrue(GrouperClientWs.mostRecentRequest,
33290           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
33291       assertTrue(GrouperClientWs.mostRecentRequest,
33292           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
33293       assertTrue(GrouperClientWs.mostRecentRequest,
33294           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
33295       assertTrue(GrouperClientWs.mostRecentRequest,
33296           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
33297 
33298 
33299 
33300       // ######################################################
33301       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups
33302 
33303       baos = new ByteArrayOutputStream();
33304       System.setOut(new PrintStream(baos));
33305 
33306       GrouperClient.main(GrouperClientUtils.splitTrim(
33307           "--operation=getAttributeAssignmentsWs --attributeAssignType=imm_mem_asgn --ownerMembershipUuids=" + membership.getImmediateMembershipId()
33308           ,
33309         " "));
33310 
33311       System.out.flush();
33312       output = new String(baos.toByteArray());
33313 
33314       System.setOut(systemOut);
33315 
33316       outputLines = GrouperClientUtils.splitTrim(output, "\n");
33317 
33318       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
33319       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
33320       pattern = Pattern
33321           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
33322 
33323       assertEquals(1, GrouperUtil.length(outputLines));
33324 
33325       outputLine = outputLines[0];
33326 
33327       matcher = pattern.matcher(outputLine);
33328 
33329       assertTrue(outputLine, matcher.matches());
33330       assertEquals(outputLine, "0", matcher.group(1));
33331       assertEquals(outputLine, "imm_mem_asgn", matcher.group(2));
33332       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
33333       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
33334       assertEquals(outputLine, "assign", matcher.group(5));
33335       assertEquals(outputLine, "123", matcher.group(6));
33336       assertEquals(outputLine, "T", matcher.group(7));
33337       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
33338 
33339       assertTrue(GrouperClientWs.mostRecentRequest,
33340           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
33341       assertTrue(GrouperClientWs.mostRecentRequest,
33342           !GrouperClientWs.mostRecentRequest.contains("<actions>"));
33343       assertTrue(GrouperClientWs.mostRecentRequest,
33344           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
33345       assertTrue(GrouperClientWs.mostRecentRequest,
33346           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
33347       assertTrue(GrouperClientWs.mostRecentRequest,
33348           !GrouperClientWs.mostRecentRequest.contains("enabled"));
33349       assertTrue(GrouperClientWs.mostRecentRequest,
33350           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
33351       assertTrue(GrouperClientWs.mostRecentRequest,
33352           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
33353       assertTrue(GrouperClientWs.mostRecentRequest,
33354           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
33355       assertTrue(GrouperClientWs.mostRecentRequest,
33356           !GrouperClientWs.mostRecentRequest.contains("params"));
33357       assertTrue(GrouperClientWs.mostRecentRequest,
33358           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
33359       assertTrue(GrouperClientWs.mostRecentRequest,
33360           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
33361       assertFalse(GrouperClientWs.mostRecentRequest,
33362           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
33363       assertTrue(GrouperClientWs.mostRecentRequest,
33364           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
33365       assertTrue(GrouperClientWs.mostRecentRequest,
33366           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
33367       assertTrue(GrouperClientWs.mostRecentRequest,
33368           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
33369       assertTrue(GrouperClientWs.mostRecentRequest,
33370           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
33371       assertTrue(GrouperClientWs.mostRecentRequest,
33372           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
33373       assertTrue(GrouperClientWs.mostRecentRequest,
33374           GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
33375       assertTrue(GrouperClientWs.mostRecentRequest,
33376           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
33377       assertTrue(GrouperClientWs.mostRecentRequest,
33378           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
33379       assertFalse(GrouperClientWs.mostRecentRequest,
33380           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
33381       assertFalse(GrouperClientWs.mostRecentRequest,
33382           GrouperClientWs.mostRecentRequest.contains("theValue"));
33383       assertFalse(GrouperClientWs.mostRecentRequest,
33384           GrouperClientWs.mostRecentRequest.contains(">123<"));
33385       assertFalse(GrouperClientWs.mostRecentRequest,
33386           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
33387       assertFalse(GrouperClientWs.mostRecentRequest,
33388           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
33389       assertTrue(GrouperClientWs.mostRecentRequest,
33390           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
33391       assertTrue(GrouperClientWs.mostRecentRequest,
33392           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
33393       assertTrue(GrouperClientWs.mostRecentRequest,
33394           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
33395       assertTrue(GrouperClientWs.mostRecentRequest,
33396           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
33397 
33398 
33399     } finally {
33400       System.setOut(systemOut);
33401     }
33402 
33403   }
33404 
33405 /**
33406    * @throws Exception
33407    */
33408   public void testGetAttributeAssignsAnyMembershipExtraFeatures() throws Exception {
33409 
33410     AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
33411     AttributeDefName attributeDefName2 = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignAssignName");
33412 
33413     final AttributeDef attributeDef = attributeDefName.getAttributeDef();
33414 
33415     attributeDef.setValueType(AttributeDefValueType.string);
33416     attributeDef.setAssignToGroup(false);
33417     attributeDef.setAssignToEffMembership(true);
33418     attributeDef.store();
33419 
33420     final AttributeDef attributeDef2 = attributeDefName2.getAttributeDef();
33421 
33422     attributeDef2.setAssignToGroup(false);
33423     attributeDef2.setAssignToEffMembershipAssn(true);
33424     attributeDef2.setValueType(AttributeDefValueType.integer);
33425     attributeDef2.store();
33426 
33427     Group group1 = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
33428       .assignGroupNameToEdit("test:anyMembershipTestAttrAssign").assignName("test:anyMembershipTestAttrAssign").assignCreateParentStemsIfNotExist(true)
33429       .assignDescription("description").save();
33430 
33431     Group group2 = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
33432       .assignGroupNameToEdit("test:anyMembershipTestAttrAssign2").assignName("test:anyMembershipTestAttrAssign2").assignCreateParentStemsIfNotExist(true)
33433       .assignDescription("description").save();
33434 
33435     //add one group to another to make effective membership and add attribute to that membership
33436     group1.addMember(group2.toSubject());
33437     group2.addMember(SubjectTestHelper.SUBJ0);
33438 
33439     Member member = MemberFinder.findBySubject(GrouperSession.staticGrouperSession(), SubjectTestHelper.SUBJ0, false);
33440 
33441     Membership membership = (Membership)MembershipFinder.findMemberships(GrouperUtil.toSet(group1.getId()),
33442         GrouperUtil.toSet(member.getUuid()), null, null, FieldFinder.find("members", true), null, null, null, null, null).iterator().next()[0];
33443 
33444     AttributeAssignResult attributeAssignResult = membership.getAttributeDelegateEffMship().assignAttribute(attributeDefName);
33445 
33446     AttributeAssign attributeAssign = attributeAssignResult.getAttributeAssign();
33447     attributeAssign.getValueDelegate().assignValue("abc");
33448 
33449     AttributeAssignResult attributeAssignResult2 = attributeAssign.getAttributeDelegate().assignAttribute(attributeDefName2);
33450     AttributeAssign attributeAssign2 = attributeAssignResult2.getAttributeAssign();
33451     attributeAssign2.getValueDelegate().assignValue("123");
33452 
33453     PrintStream systemOut = System.out;
33454 
33455     ByteArrayOutputStream baos = new ByteArrayOutputStream();
33456     System.setOut(new PrintStream(baos));
33457 
33458     try {
33459 
33460       GrouperClient.main(GrouperClientUtils.splitTrim(
33461           "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem " +
33462           "--attributeDefNames=test:testAttributeAssignDefNameDef " +
33463           "--attributeDefValueType=string --value=abc",
33464           " "));
33465       System.out.flush();
33466       String output = new String(baos.toByteArray());
33467 
33468       System.setOut(systemOut);
33469 
33470       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
33471 
33472       // match: Index: 0: attributeAssignType: group, owner: test:groupTestAttrAssign, attributeDefNameName test:testAttributeAssignDefName, action: assign, values: 15,5,5, enable: T, id: a9c83eeb78c04ae5befcea36272d318c
33473       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
33474       Pattern pattern = Pattern
33475           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
33476 
33477       assertEquals(1, GrouperUtil.length(outputLines));
33478       String outputLine = outputLines[0];
33479 
33480       Matcher matcher = pattern.matcher(outputLines[0]);
33481 
33482       assertTrue(outputLine, matcher.matches());
33483       assertEquals(outputLine, "0", matcher.group(1));
33484       assertEquals(outputLine, "any_mem", matcher.group(2));
33485       assertEquals(outputLine, "test:anyMembershipTestAttrAssign - jdbc - test.subject.0", matcher.group(3));
33486       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
33487       assertEquals(outputLine, "assign", matcher.group(5));
33488       assertEquals(outputLine, "abc", matcher.group(6));
33489       assertEquals(outputLine, "T", matcher.group(7));
33490       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
33491 
33492       assertTrue(GrouperClientWs.mostRecentRequest,
33493           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
33494       assertTrue(GrouperClientWs.mostRecentRequest,
33495           !GrouperClientWs.mostRecentRequest.contains("actions"));
33496       assertTrue(GrouperClientWs.mostRecentRequest,
33497           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
33498       assertTrue(GrouperClientWs.mostRecentRequest,
33499           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
33500       assertTrue(GrouperClientWs.mostRecentRequest,
33501           !GrouperClientWs.mostRecentRequest.contains("enabled"));
33502       assertTrue(GrouperClientWs.mostRecentRequest,
33503           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
33504       assertTrue(GrouperClientWs.mostRecentRequest,
33505           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
33506       assertTrue(GrouperClientWs.mostRecentRequest,
33507           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
33508       assertTrue(GrouperClientWs.mostRecentRequest,
33509           !GrouperClientWs.mostRecentRequest.contains("params"));
33510       assertTrue(GrouperClientWs.mostRecentRequest,
33511           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
33512       assertTrue(GrouperClientWs.mostRecentRequest,
33513           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
33514       assertTrue(GrouperClientWs.mostRecentRequest,
33515           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
33516       assertTrue(GrouperClientWs.mostRecentRequest,
33517           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
33518       assertTrue(GrouperClientWs.mostRecentRequest,
33519           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
33520       assertTrue(GrouperClientWs.mostRecentRequest,
33521           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
33522       assertTrue(GrouperClientWs.mostRecentRequest,
33523           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
33524       assertTrue(GrouperClientWs.mostRecentRequest,
33525           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
33526       assertTrue(GrouperClientWs.mostRecentRequest,
33527           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
33528       assertTrue(GrouperClientWs.mostRecentRequest,
33529           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
33530       assertTrue(GrouperClientWs.mostRecentRequest,
33531           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
33532       assertTrue(GrouperClientWs.mostRecentRequest,
33533           GrouperClientWs.mostRecentRequest.contains("theValue"));
33534       assertTrue(GrouperClientWs.mostRecentRequest,
33535           GrouperClientWs.mostRecentRequest.contains("abc"));
33536       assertTrue(GrouperClientWs.mostRecentRequest,
33537           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
33538       assertTrue(GrouperClientWs.mostRecentRequest,
33539           !GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
33540       assertTrue(GrouperClientWs.mostRecentRequest,
33541           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
33542       assertTrue(GrouperClientWs.mostRecentRequest,
33543           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
33544       assertTrue(GrouperClientWs.mostRecentRequest,
33545           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
33546       assertTrue(GrouperClientWs.mostRecentRequest,
33547           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
33548       assertTrue(GrouperClientWs.mostRecentRequest,
33549           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
33550       assertTrue(GrouperClientWs.mostRecentRequest,
33551           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
33552 
33553       // ######################################################
33554       // Try wrong value
33555 
33556       baos = new ByteArrayOutputStream();
33557       System.setOut(new PrintStream(baos));
33558 
33559       GrouperClient.main(GrouperClientUtils.splitTrim(
33560           "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem --attributeDefUuids=" + attributeDef.getId() +
33561           " --attributeDefNames=test:testAttributeAssignDefNameDef " +
33562           "--attributeDefValueType=string --value=123",
33563           " "));
33564 
33565 
33566       System.out.flush();
33567       output = new String(baos.toByteArray());
33568 
33569       System.setOut(systemOut);
33570 
33571       outputLines = GrouperClientUtils.splitTrim(output, "\n");
33572 
33573       assertEquals(0, GrouperUtil.length(outputLines));
33574 //      outputLine = outputLines[0];
33575 //
33576 //      matcher = pattern.matcher(outputLines[0]);
33577 
33578       assertTrue(GrouperClientWs.mostRecentRequest,
33579           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
33580       assertTrue(GrouperClientWs.mostRecentRequest,
33581           !GrouperClientWs.mostRecentRequest.contains("actions"));
33582       assertTrue(GrouperClientWs.mostRecentRequest,
33583           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
33584       assertTrue(GrouperClientWs.mostRecentRequest,
33585           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
33586       assertTrue(GrouperClientWs.mostRecentRequest,
33587           !GrouperClientWs.mostRecentRequest.contains("enabled"));
33588       assertTrue(GrouperClientWs.mostRecentRequest,
33589           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
33590       assertTrue(GrouperClientWs.mostRecentRequest,
33591           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
33592       assertTrue(GrouperClientWs.mostRecentRequest,
33593           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
33594       assertTrue(GrouperClientWs.mostRecentRequest,
33595           !GrouperClientWs.mostRecentRequest.contains("params"));
33596       assertTrue(GrouperClientWs.mostRecentRequest,
33597           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
33598       assertTrue(GrouperClientWs.mostRecentRequest,
33599           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
33600       assertTrue(GrouperClientWs.mostRecentRequest,
33601           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<name>"));
33602       assertTrue(GrouperClientWs.mostRecentRequest,
33603           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
33604       assertTrue(GrouperClientWs.mostRecentRequest,
33605           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
33606       assertTrue(GrouperClientWs.mostRecentRequest,
33607           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
33608       assertTrue(GrouperClientWs.mostRecentRequest,
33609           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
33610       assertTrue(GrouperClientWs.mostRecentRequest,
33611           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
33612       assertTrue(GrouperClientWs.mostRecentRequest,
33613           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
33614       assertTrue(GrouperClientWs.mostRecentRequest,
33615           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
33616       assertTrue(GrouperClientWs.mostRecentRequest,
33617           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
33618       assertTrue(GrouperClientWs.mostRecentRequest,
33619           GrouperClientWs.mostRecentRequest.contains("theValue"));
33620       assertTrue(GrouperClientWs.mostRecentRequest,
33621           GrouperClientWs.mostRecentRequest.contains(">123<"));
33622       assertTrue(GrouperClientWs.mostRecentRequest,
33623           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
33624       assertTrue(GrouperClientWs.mostRecentRequest,
33625           !GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
33626       assertTrue(GrouperClientWs.mostRecentRequest,
33627           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
33628       assertTrue(GrouperClientWs.mostRecentRequest,
33629           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
33630       assertTrue(GrouperClientWs.mostRecentRequest,
33631           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
33632       assertTrue(GrouperClientWs.mostRecentRequest,
33633           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
33634       assertTrue(GrouperClientWs.mostRecentRequest,
33635           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
33636       assertTrue(GrouperClientWs.mostRecentRequest,
33637           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
33638 
33639 
33640       // ######################################################
33641       // Try wrong id
33642 
33643       baos = new ByteArrayOutputStream();
33644       System.setOut(new PrintStream(baos));
33645 
33646       try {
33647         GrouperClient.main(GrouperClientUtils.splitTrim(
33648             " --operation=getAttributeAssignmentsWs --attributeAssignType=any_mem --attributeDefUuids=123" + attributeDef.getId() +
33649             " --attributeDefNames=test:testAttributeAssignDefNameDef " +
33650             "--attributeDefValueType=string --value=123",
33651             " "));
33652         fail("Shouldnt get here");
33653       } catch (GcWebServiceError gwse) {
33654         //ignore
33655       }
33656 
33657       // ######################################################
33658       // Try correct attributeDefType
33659 
33660       baos = new ByteArrayOutputStream();
33661       System.setOut(new PrintStream(baos));
33662 
33663       GrouperClient.main(GrouperClientUtils.splitTrim(
33664           "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem --attributeDefUuids=" + attributeDef.getId() +
33665           " --attributeDefValueType=string --value=abc --attributeDefType=attr",
33666           " "));
33667 
33668 
33669       System.out.flush();
33670       output = new String(baos.toByteArray());
33671 
33672       System.setOut(systemOut);
33673 
33674       outputLines = GrouperClientUtils.splitTrim(output, "\n");
33675 
33676       // match: Index: 0: attributeAssignType: group, owner: test:anyMembershipTestAttrAssign - jdbc - test.subject.0, attributeDefNameName test:testAttributeAssignDefName, action: assign, values: 15,5,5, enable: T, id: a9c83eeb78c04ae5befcea36272d318c
33677       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
33678       pattern = Pattern
33679           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
33680 
33681       assertEquals(1, GrouperUtil.length(outputLines));
33682       outputLine = outputLines[0];
33683 
33684       matcher = pattern.matcher(outputLines[0]);
33685 
33686       assertTrue(outputLine, matcher.matches());
33687       assertEquals(outputLine, "0", matcher.group(1));
33688       assertEquals(outputLine, "any_mem", matcher.group(2));
33689       assertEquals(outputLine, "test:anyMembershipTestAttrAssign - jdbc - test.subject.0", matcher.group(3));
33690       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
33691       assertEquals(outputLine, "assign", matcher.group(5));
33692       assertEquals(outputLine, "abc", matcher.group(6));
33693       assertEquals(outputLine, "T", matcher.group(7));
33694       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
33695 
33696       assertTrue(GrouperClientWs.mostRecentRequest,
33697           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
33698       assertTrue(GrouperClientWs.mostRecentRequest,
33699           !GrouperClientWs.mostRecentRequest.contains("actions"));
33700       assertTrue(GrouperClientWs.mostRecentRequest,
33701           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
33702       assertTrue(GrouperClientWs.mostRecentRequest,
33703           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
33704       assertTrue(GrouperClientWs.mostRecentRequest,
33705           !GrouperClientWs.mostRecentRequest.contains("enabled"));
33706       assertTrue(GrouperClientWs.mostRecentRequest,
33707           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
33708       assertTrue(GrouperClientWs.mostRecentRequest,
33709           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
33710       assertTrue(GrouperClientWs.mostRecentRequest,
33711           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
33712       assertTrue(GrouperClientWs.mostRecentRequest,
33713           !GrouperClientWs.mostRecentRequest.contains("params"));
33714       assertTrue(GrouperClientWs.mostRecentRequest,
33715           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
33716       assertTrue(GrouperClientWs.mostRecentRequest,
33717           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
33718       assertTrue(GrouperClientWs.mostRecentRequest,
33719           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
33720       assertTrue(GrouperClientWs.mostRecentRequest,
33721           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
33722       assertTrue(GrouperClientWs.mostRecentRequest,
33723           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
33724       assertTrue(GrouperClientWs.mostRecentRequest,
33725           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
33726       assertTrue(GrouperClientWs.mostRecentRequest,
33727           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
33728       assertTrue(GrouperClientWs.mostRecentRequest,
33729           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
33730       assertTrue(GrouperClientWs.mostRecentRequest,
33731           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
33732       assertTrue(GrouperClientWs.mostRecentRequest,
33733           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
33734       assertTrue(GrouperClientWs.mostRecentRequest,
33735           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
33736       assertTrue(GrouperClientWs.mostRecentRequest,
33737           GrouperClientWs.mostRecentRequest.contains("theValue"));
33738       assertTrue(GrouperClientWs.mostRecentRequest,
33739           GrouperClientWs.mostRecentRequest.contains("abc"));
33740       assertTrue(GrouperClientWs.mostRecentRequest,
33741           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
33742       assertTrue(GrouperClientWs.mostRecentRequest,
33743           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
33744       assertTrue(GrouperClientWs.mostRecentRequest,
33745           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
33746       assertTrue(GrouperClientWs.mostRecentRequest,
33747           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
33748       assertTrue(GrouperClientWs.mostRecentRequest,
33749           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
33750       assertTrue(GrouperClientWs.mostRecentRequest,
33751           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
33752       assertTrue(GrouperClientWs.mostRecentRequest,
33753           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
33754       assertTrue(GrouperClientWs.mostRecentRequest,
33755           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
33756 
33757       // ######################################################
33758       // Try wrong attributeDefType
33759 
33760       baos = new ByteArrayOutputStream();
33761       System.setOut(new PrintStream(baos));
33762 
33763       GrouperClient.main(GrouperClientUtils.splitTrim(
33764           "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem --attributeDefUuids=" + attributeDef.getId() +
33765           " --attributeDefValueType=string --value=abc --attributeDefType=limit",
33766           " "));
33767 
33768       System.out.flush();
33769       output = new String(baos.toByteArray());
33770 
33771       System.setOut(systemOut);
33772 
33773       outputLines = GrouperClientUtils.splitTrim(output, "\n");
33774 
33775       // match: Index: 0: attributeAssignType: group, owner: test:anyMembershipTestAttrAssign - jdbc - test.subject.0, attributeDefNameName test:testAttributeAssignDefName, action: assign, values: 15,5,5, enable: T, id: a9c83eeb78c04ae5befcea36272d318c
33776       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
33777       pattern = Pattern
33778           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
33779 
33780       assertEquals(0, GrouperUtil.length(outputLines));
33781 
33782       assertTrue(GrouperClientWs.mostRecentRequest,
33783           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
33784       assertTrue(GrouperClientWs.mostRecentRequest,
33785           !GrouperClientWs.mostRecentRequest.contains("actions"));
33786       assertTrue(GrouperClientWs.mostRecentRequest,
33787           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
33788       assertTrue(GrouperClientWs.mostRecentRequest,
33789           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
33790       assertTrue(GrouperClientWs.mostRecentRequest,
33791           !GrouperClientWs.mostRecentRequest.contains("enabled"));
33792       assertTrue(GrouperClientWs.mostRecentRequest,
33793           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
33794       assertTrue(GrouperClientWs.mostRecentRequest,
33795           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
33796       assertTrue(GrouperClientWs.mostRecentRequest,
33797           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
33798       assertTrue(GrouperClientWs.mostRecentRequest,
33799           !GrouperClientWs.mostRecentRequest.contains("params"));
33800       assertTrue(GrouperClientWs.mostRecentRequest,
33801           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
33802       assertTrue(GrouperClientWs.mostRecentRequest,
33803           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
33804       assertTrue(GrouperClientWs.mostRecentRequest,
33805           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
33806       assertTrue(GrouperClientWs.mostRecentRequest,
33807           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
33808       assertTrue(GrouperClientWs.mostRecentRequest,
33809           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
33810       assertTrue(GrouperClientWs.mostRecentRequest,
33811           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
33812       assertTrue(GrouperClientWs.mostRecentRequest,
33813           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
33814       assertTrue(GrouperClientWs.mostRecentRequest,
33815           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
33816       assertTrue(GrouperClientWs.mostRecentRequest,
33817           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
33818       assertTrue(GrouperClientWs.mostRecentRequest,
33819           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
33820       assertTrue(GrouperClientWs.mostRecentRequest,
33821           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
33822       assertTrue(GrouperClientWs.mostRecentRequest,
33823           GrouperClientWs.mostRecentRequest.contains("theValue"));
33824       assertTrue(GrouperClientWs.mostRecentRequest,
33825           GrouperClientWs.mostRecentRequest.contains("abc"));
33826       assertTrue(GrouperClientWs.mostRecentRequest,
33827           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
33828       assertTrue(GrouperClientWs.mostRecentRequest,
33829           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
33830       assertTrue(GrouperClientWs.mostRecentRequest,
33831           GrouperClientWs.mostRecentRequest.contains("limit"));
33832       assertTrue(GrouperClientWs.mostRecentRequest,
33833           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
33834       assertTrue(GrouperClientWs.mostRecentRequest,
33835           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
33836       assertTrue(GrouperClientWs.mostRecentRequest,
33837           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
33838       assertTrue(GrouperClientWs.mostRecentRequest,
33839           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
33840       assertTrue(GrouperClientWs.mostRecentRequest,
33841           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
33842       assertTrue(GrouperClientWs.mostRecentRequest,
33843           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
33844 
33845       // ######################################################
33846       // Try group assignment on assignment by attributeDef
33847 
33848       baos = new ByteArrayOutputStream();
33849       System.setOut(new PrintStream(baos));
33850 
33851       GrouperClient.main(GrouperClientUtils.splitTrim(
33852           "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --attributeDefUuids=" + attributeDef2.getId(),
33853           " "));
33854 
33855       System.out.flush();
33856       output = new String(baos.toByteArray());
33857 
33858       System.setOut(systemOut);
33859 
33860       outputLines = GrouperClientUtils.splitTrim(output, "\n");
33861 
33862       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
33863       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
33864       pattern = Pattern
33865           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
33866 
33867       assertEquals(1, GrouperUtil.length(outputLines));
33868       outputLine = outputLines[0];
33869 
33870       matcher = pattern.matcher(outputLines[0]);
33871 
33872       assertTrue(outputLine, matcher.matches());
33873       assertEquals(outputLine, "0", matcher.group(1));
33874       assertEquals(outputLine, "any_mem_asgn", matcher.group(2));
33875       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
33876       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
33877       assertEquals(outputLine, "assign", matcher.group(5));
33878       assertEquals(outputLine, "123", matcher.group(6));
33879       assertEquals(outputLine, "T", matcher.group(7));
33880       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
33881 
33882       assertTrue(GrouperClientWs.mostRecentRequest,
33883           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
33884       assertTrue(GrouperClientWs.mostRecentRequest,
33885           !GrouperClientWs.mostRecentRequest.contains("actions"));
33886       assertTrue(GrouperClientWs.mostRecentRequest,
33887           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
33888       assertTrue(GrouperClientWs.mostRecentRequest,
33889           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
33890       assertTrue(GrouperClientWs.mostRecentRequest,
33891           !GrouperClientWs.mostRecentRequest.contains("enabled"));
33892       assertTrue(GrouperClientWs.mostRecentRequest,
33893           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
33894       assertTrue(GrouperClientWs.mostRecentRequest,
33895           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
33896       assertTrue(GrouperClientWs.mostRecentRequest,
33897           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
33898       assertTrue(GrouperClientWs.mostRecentRequest,
33899           !GrouperClientWs.mostRecentRequest.contains("params"));
33900       assertTrue(GrouperClientWs.mostRecentRequest,
33901           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
33902       assertTrue(GrouperClientWs.mostRecentRequest,
33903           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
33904       assertTrue(GrouperClientWs.mostRecentRequest,
33905           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
33906       assertTrue(GrouperClientWs.mostRecentRequest,
33907           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
33908       assertTrue(GrouperClientWs.mostRecentRequest,
33909           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
33910       assertTrue(GrouperClientWs.mostRecentRequest,
33911           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
33912       assertTrue(GrouperClientWs.mostRecentRequest,
33913           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
33914       assertTrue(GrouperClientWs.mostRecentRequest,
33915           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
33916       assertTrue(GrouperClientWs.mostRecentRequest,
33917           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
33918       assertTrue(GrouperClientWs.mostRecentRequest,
33919           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
33920       assertFalse(GrouperClientWs.mostRecentRequest,
33921           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
33922       assertFalse(GrouperClientWs.mostRecentRequest,
33923           GrouperClientWs.mostRecentRequest.contains("theValue"));
33924       assertFalse(GrouperClientWs.mostRecentRequest,
33925           GrouperClientWs.mostRecentRequest.contains(">abc<"));
33926       assertTrue(GrouperClientWs.mostRecentRequest,
33927           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
33928       assertFalse(GrouperClientWs.mostRecentRequest,
33929           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
33930       assertTrue(GrouperClientWs.mostRecentRequest,
33931           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
33932       assertTrue(GrouperClientWs.mostRecentRequest,
33933           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
33934       assertTrue(GrouperClientWs.mostRecentRequest,
33935           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
33936       assertTrue(GrouperClientWs.mostRecentRequest,
33937           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
33938       assertTrue(GrouperClientWs.mostRecentRequest,
33939           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
33940       assertTrue(GrouperClientWs.mostRecentRequest,
33941           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
33942 
33943 
33944       // ######################################################
33945       // Try group assignment on assignment by attributeDef
33946 
33947       baos = new ByteArrayOutputStream();
33948       System.setOut(new PrintStream(baos));
33949 
33950       GrouperClient.main(GrouperClientUtils.splitTrim(
33951           "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --attributeDefIdIndexes=" + attributeDef2.getIdIndex(),
33952           " "));
33953 
33954       System.out.flush();
33955       output = new String(baos.toByteArray());
33956 
33957       System.setOut(systemOut);
33958 
33959       outputLines = GrouperClientUtils.splitTrim(output, "\n");
33960 
33961       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
33962       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
33963       pattern = Pattern
33964           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
33965 
33966       assertEquals(1, GrouperUtil.length(outputLines));
33967       outputLine = outputLines[0];
33968 
33969       matcher = pattern.matcher(outputLines[0]);
33970 
33971       assertTrue(outputLine, matcher.matches());
33972       assertEquals(outputLine, "0", matcher.group(1));
33973       assertEquals(outputLine, "any_mem_asgn", matcher.group(2));
33974       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
33975       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
33976       assertEquals(outputLine, "assign", matcher.group(5));
33977       assertEquals(outputLine, "123", matcher.group(6));
33978       assertEquals(outputLine, "T", matcher.group(7));
33979       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
33980 
33981       assertTrue(GrouperClientWs.mostRecentRequest,
33982           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
33983       assertTrue(GrouperClientWs.mostRecentRequest,
33984           !GrouperClientWs.mostRecentRequest.contains("actions"));
33985       assertTrue(GrouperClientWs.mostRecentRequest,
33986           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
33987       assertTrue(GrouperClientWs.mostRecentRequest,
33988           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
33989       assertTrue(GrouperClientWs.mostRecentRequest,
33990           !GrouperClientWs.mostRecentRequest.contains("enabled"));
33991       assertTrue(GrouperClientWs.mostRecentRequest,
33992           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
33993       assertTrue(GrouperClientWs.mostRecentRequest,
33994           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
33995       assertTrue(GrouperClientWs.mostRecentRequest,
33996           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
33997       assertTrue(GrouperClientWs.mostRecentRequest,
33998           !GrouperClientWs.mostRecentRequest.contains("params"));
33999       assertTrue(GrouperClientWs.mostRecentRequest,
34000           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
34001       assertTrue(GrouperClientWs.mostRecentRequest,
34002           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
34003       assertTrue(GrouperClientWs.mostRecentRequest,
34004           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<idIndex>"));
34005       assertTrue(GrouperClientWs.mostRecentRequest,
34006           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
34007       assertTrue(GrouperClientWs.mostRecentRequest,
34008           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
34009       assertTrue(GrouperClientWs.mostRecentRequest,
34010           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
34011       assertTrue(GrouperClientWs.mostRecentRequest,
34012           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
34013       assertTrue(GrouperClientWs.mostRecentRequest,
34014           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
34015       assertTrue(GrouperClientWs.mostRecentRequest,
34016           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
34017       assertTrue(GrouperClientWs.mostRecentRequest,
34018           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
34019       assertFalse(GrouperClientWs.mostRecentRequest,
34020           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
34021       assertFalse(GrouperClientWs.mostRecentRequest,
34022           GrouperClientWs.mostRecentRequest.contains("theValue"));
34023       assertFalse(GrouperClientWs.mostRecentRequest,
34024           GrouperClientWs.mostRecentRequest.contains(">abc<"));
34025       assertTrue(GrouperClientWs.mostRecentRequest,
34026           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
34027       assertFalse(GrouperClientWs.mostRecentRequest,
34028           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
34029       assertTrue(GrouperClientWs.mostRecentRequest,
34030           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
34031       assertTrue(GrouperClientWs.mostRecentRequest,
34032           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
34033       assertTrue(GrouperClientWs.mostRecentRequest,
34034           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
34035       assertTrue(GrouperClientWs.mostRecentRequest,
34036           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
34037       assertTrue(GrouperClientWs.mostRecentRequest,
34038           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
34039       assertTrue(GrouperClientWs.mostRecentRequest,
34040           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
34041 
34042       // ######################################################
34043       // Try group assignment on assignment by attributeDef with wrong id
34044 
34045       baos = new ByteArrayOutputStream();
34046       System.setOut(new PrintStream(baos));
34047 
34048       try {
34049         GrouperClient.main(GrouperClientUtils.splitTrim(
34050             "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --attributeDefUuids=1" + attributeDef2.getId(),
34051             " "));
34052 
34053         System.out.flush();
34054         output = new String(baos.toByteArray());
34055 
34056         System.setOut(systemOut);
34057 
34058         outputLines = GrouperClientUtils.splitTrim(output, "\n");
34059 
34060         // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
34061         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
34062         pattern = Pattern
34063             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
34064 
34065         assertEquals(0, GrouperUtil.length(outputLines));
34066         fail("Why did it not fail?");
34067       } catch (Exception e) {
34068         //good
34069       }
34070       assertTrue(GrouperClientWs.mostRecentRequest,
34071           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
34072       assertTrue(GrouperClientWs.mostRecentRequest,
34073           !GrouperClientWs.mostRecentRequest.contains("actions"));
34074       assertTrue(GrouperClientWs.mostRecentRequest,
34075           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
34076       assertTrue(GrouperClientWs.mostRecentRequest,
34077           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
34078       assertTrue(GrouperClientWs.mostRecentRequest,
34079           !GrouperClientWs.mostRecentRequest.contains("enabled"));
34080       assertTrue(GrouperClientWs.mostRecentRequest,
34081           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
34082       assertTrue(GrouperClientWs.mostRecentRequest,
34083           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
34084       assertTrue(GrouperClientWs.mostRecentRequest,
34085           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
34086       assertTrue(GrouperClientWs.mostRecentRequest,
34087           !GrouperClientWs.mostRecentRequest.contains("params"));
34088       assertTrue(GrouperClientWs.mostRecentRequest,
34089           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
34090       assertTrue(GrouperClientWs.mostRecentRequest,
34091           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
34092       assertTrue(GrouperClientWs.mostRecentRequest,
34093           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
34094       assertTrue(GrouperClientWs.mostRecentRequest,
34095           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
34096       assertTrue(GrouperClientWs.mostRecentRequest,
34097           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
34098       assertTrue(GrouperClientWs.mostRecentRequest,
34099           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
34100       assertTrue(GrouperClientWs.mostRecentRequest,
34101           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
34102       assertTrue(GrouperClientWs.mostRecentRequest,
34103           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
34104       assertTrue(GrouperClientWs.mostRecentRequest,
34105           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
34106       assertTrue(GrouperClientWs.mostRecentRequest,
34107           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
34108       assertFalse(GrouperClientWs.mostRecentRequest,
34109           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
34110       assertFalse(GrouperClientWs.mostRecentRequest,
34111           GrouperClientWs.mostRecentRequest.contains("theValue"));
34112       assertFalse(GrouperClientWs.mostRecentRequest,
34113           GrouperClientWs.mostRecentRequest.contains("abc"));
34114       assertTrue(GrouperClientWs.mostRecentRequest,
34115           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
34116       assertFalse(GrouperClientWs.mostRecentRequest,
34117           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
34118       assertTrue(GrouperClientWs.mostRecentRequest,
34119           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
34120       assertTrue(GrouperClientWs.mostRecentRequest,
34121           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
34122       assertTrue(GrouperClientWs.mostRecentRequest,
34123           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
34124       assertTrue(GrouperClientWs.mostRecentRequest,
34125           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
34126       assertTrue(GrouperClientWs.mostRecentRequest,
34127           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
34128       assertTrue(GrouperClientWs.mostRecentRequest,
34129           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
34130 
34131 
34132       // ######################################################
34133       // Try group assignment on assignment by attributeDef and value
34134 
34135       baos = new ByteArrayOutputStream();
34136       System.setOut(new PrintStream(baos));
34137 
34138       GrouperClient.main(GrouperClientUtils.splitTrim(
34139           "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --attributeDefUuids=" + attributeDef2.getId()
34140           + " --attributeDefValueType=integer --value=123 ",
34141         " "));
34142 
34143       System.out.flush();
34144       output = new String(baos.toByteArray());
34145 
34146       System.setOut(systemOut);
34147 
34148       outputLines = GrouperClientUtils.splitTrim(output, "\n");
34149 
34150       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
34151       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
34152       pattern = Pattern
34153           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
34154 
34155       assertEquals(1, GrouperUtil.length(outputLines));
34156       outputLine = outputLines[0];
34157 
34158       matcher = pattern.matcher(outputLines[0]);
34159 
34160       assertTrue(outputLine, matcher.matches());
34161       assertEquals(outputLine, "0", matcher.group(1));
34162       assertEquals(outputLine, "any_mem_asgn", matcher.group(2));
34163       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
34164       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
34165       assertEquals(outputLine, "assign", matcher.group(5));
34166       assertEquals(outputLine, "123", matcher.group(6));
34167       assertEquals(outputLine, "T", matcher.group(7));
34168       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
34169 
34170       assertTrue(GrouperClientWs.mostRecentRequest,
34171           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
34172       assertTrue(GrouperClientWs.mostRecentRequest,
34173           !GrouperClientWs.mostRecentRequest.contains("actions"));
34174       assertTrue(GrouperClientWs.mostRecentRequest,
34175           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
34176       assertTrue(GrouperClientWs.mostRecentRequest,
34177           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
34178       assertTrue(GrouperClientWs.mostRecentRequest,
34179           !GrouperClientWs.mostRecentRequest.contains("enabled"));
34180       assertTrue(GrouperClientWs.mostRecentRequest,
34181           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
34182       assertTrue(GrouperClientWs.mostRecentRequest,
34183           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
34184       assertTrue(GrouperClientWs.mostRecentRequest,
34185           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
34186       assertTrue(GrouperClientWs.mostRecentRequest,
34187           !GrouperClientWs.mostRecentRequest.contains("params"));
34188       assertTrue(GrouperClientWs.mostRecentRequest,
34189           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
34190       assertTrue(GrouperClientWs.mostRecentRequest,
34191           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
34192       assertTrue(GrouperClientWs.mostRecentRequest,
34193           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
34194       assertTrue(GrouperClientWs.mostRecentRequest,
34195           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
34196       assertTrue(GrouperClientWs.mostRecentRequest,
34197           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
34198       assertTrue(GrouperClientWs.mostRecentRequest,
34199           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
34200       assertTrue(GrouperClientWs.mostRecentRequest,
34201           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
34202       assertTrue(GrouperClientWs.mostRecentRequest,
34203           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
34204       assertTrue(GrouperClientWs.mostRecentRequest,
34205           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
34206       assertTrue(GrouperClientWs.mostRecentRequest,
34207           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
34208       assertTrue(GrouperClientWs.mostRecentRequest,
34209           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
34210       assertTrue(GrouperClientWs.mostRecentRequest,
34211           GrouperClientWs.mostRecentRequest.contains("theValue"));
34212       assertTrue(GrouperClientWs.mostRecentRequest,
34213           GrouperClientWs.mostRecentRequest.contains(">123<"));
34214       assertTrue(GrouperClientWs.mostRecentRequest,
34215           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
34216       assertFalse(GrouperClientWs.mostRecentRequest,
34217           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
34218       assertTrue(GrouperClientWs.mostRecentRequest,
34219           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
34220       assertTrue(GrouperClientWs.mostRecentRequest,
34221           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
34222       assertTrue(GrouperClientWs.mostRecentRequest,
34223           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
34224       assertTrue(GrouperClientWs.mostRecentRequest,
34225           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
34226       assertTrue(GrouperClientWs.mostRecentRequest,
34227           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
34228       assertTrue(GrouperClientWs.mostRecentRequest,
34229           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
34230 
34231 
34232       // ######################################################
34233       // Try group assignment on assignment by attributeDef and wrong value
34234 
34235       baos = new ByteArrayOutputStream();
34236       System.setOut(new PrintStream(baos));
34237 
34238       GrouperClient.main(GrouperClientUtils.splitTrim(
34239           "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --attributeDefUuids=" + attributeDef2.getId()
34240           + " --attributeDefValueType=integer --value=1234 ",
34241         " "));
34242 
34243       System.out.flush();
34244       output = new String(baos.toByteArray());
34245 
34246       System.setOut(systemOut);
34247 
34248       outputLines = GrouperClientUtils.splitTrim(output, "\n");
34249 
34250       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
34251       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
34252       pattern = Pattern
34253           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
34254 
34255       assertEquals(0, GrouperUtil.length(outputLines));
34256 
34257       assertTrue(GrouperClientWs.mostRecentRequest,
34258           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
34259       assertTrue(GrouperClientWs.mostRecentRequest,
34260           !GrouperClientWs.mostRecentRequest.contains("actions"));
34261       assertTrue(GrouperClientWs.mostRecentRequest,
34262           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
34263       assertTrue(GrouperClientWs.mostRecentRequest,
34264           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
34265       assertTrue(GrouperClientWs.mostRecentRequest,
34266           !GrouperClientWs.mostRecentRequest.contains("enabled"));
34267       assertTrue(GrouperClientWs.mostRecentRequest,
34268           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
34269       assertTrue(GrouperClientWs.mostRecentRequest,
34270           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
34271       assertTrue(GrouperClientWs.mostRecentRequest,
34272           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
34273       assertTrue(GrouperClientWs.mostRecentRequest,
34274           !GrouperClientWs.mostRecentRequest.contains("params"));
34275       assertTrue(GrouperClientWs.mostRecentRequest,
34276           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
34277       assertTrue(GrouperClientWs.mostRecentRequest,
34278           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
34279       assertTrue(GrouperClientWs.mostRecentRequest,
34280           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
34281       assertTrue(GrouperClientWs.mostRecentRequest,
34282           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
34283       assertTrue(GrouperClientWs.mostRecentRequest,
34284           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
34285       assertTrue(GrouperClientWs.mostRecentRequest,
34286           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
34287       assertTrue(GrouperClientWs.mostRecentRequest,
34288           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
34289       assertTrue(GrouperClientWs.mostRecentRequest,
34290           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
34291       assertTrue(GrouperClientWs.mostRecentRequest,
34292           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
34293       assertTrue(GrouperClientWs.mostRecentRequest,
34294           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
34295       assertTrue(GrouperClientWs.mostRecentRequest,
34296           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
34297       assertTrue(GrouperClientWs.mostRecentRequest,
34298           GrouperClientWs.mostRecentRequest.contains("theValue"));
34299       assertTrue(GrouperClientWs.mostRecentRequest,
34300           GrouperClientWs.mostRecentRequest.contains("1234"));
34301       assertTrue(GrouperClientWs.mostRecentRequest,
34302           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
34303       assertFalse(GrouperClientWs.mostRecentRequest,
34304           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
34305       assertTrue(GrouperClientWs.mostRecentRequest,
34306           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
34307       assertTrue(GrouperClientWs.mostRecentRequest,
34308           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
34309       assertTrue(GrouperClientWs.mostRecentRequest,
34310           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
34311       assertTrue(GrouperClientWs.mostRecentRequest,
34312           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
34313       assertTrue(GrouperClientWs.mostRecentRequest,
34314           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
34315       assertTrue(GrouperClientWs.mostRecentRequest,
34316           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
34317 
34318 
34319       // ######################################################
34320       // Try group assignment on assignment by attributeDef and value
34321 
34322       baos = new ByteArrayOutputStream();
34323       System.setOut(new PrintStream(baos));
34324 
34325       GrouperClient.main(GrouperClientUtils.splitTrim(
34326           "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --attributeDefUuids=" + attributeDef2.getId()
34327           + " --includeAssignmentsFromAssignments=T ",
34328         " "));
34329 
34330       System.out.flush();
34331       output = new String(baos.toByteArray());
34332 
34333       System.setOut(systemOut);
34334 
34335       outputLines = GrouperClientUtils.splitTrim(output, "\n");
34336 
34337       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
34338       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
34339       pattern = Pattern
34340           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
34341 
34342       assertEquals(2, GrouperUtil.length(outputLines));
34343       outputLine = outputLines[0];
34344 
34345       matcher = pattern.matcher(outputLine);
34346 
34347       assertTrue(outputLine, matcher.matches());
34348       assertEquals(outputLine, "0", matcher.group(1));
34349       assertEquals(outputLine, "any_mem", matcher.group(2));
34350       assertEquals(outputLine, "test:anyMembershipTestAttrAssign - jdbc - test.subject.0", matcher.group(3));
34351       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(4));
34352       assertEquals(outputLine, "assign", matcher.group(5));
34353       assertEquals(outputLine, "abc", matcher.group(6));
34354       assertEquals(outputLine, "T", matcher.group(7));
34355       assertEquals(outputLine, attributeAssign.getId(), matcher.group(8));
34356 
34357       outputLine = outputLines[1];
34358 
34359       matcher = pattern.matcher(outputLine);
34360 
34361       assertTrue(outputLine, matcher.matches());
34362       assertEquals(outputLine, "1", matcher.group(1));
34363       assertEquals(outputLine, "any_mem_asgn", matcher.group(2));
34364       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
34365       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
34366       assertEquals(outputLine, "assign", matcher.group(5));
34367       assertEquals(outputLine, "123", matcher.group(6));
34368       assertEquals(outputLine, "T", matcher.group(7));
34369       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
34370 
34371       assertTrue(GrouperClientWs.mostRecentRequest,
34372           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
34373       assertTrue(GrouperClientWs.mostRecentRequest,
34374           !GrouperClientWs.mostRecentRequest.contains("actions"));
34375       assertTrue(GrouperClientWs.mostRecentRequest,
34376           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
34377       assertTrue(GrouperClientWs.mostRecentRequest,
34378           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
34379       assertTrue(GrouperClientWs.mostRecentRequest,
34380           !GrouperClientWs.mostRecentRequest.contains("enabled"));
34381       assertTrue(GrouperClientWs.mostRecentRequest,
34382           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
34383       assertTrue(GrouperClientWs.mostRecentRequest,
34384           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
34385       assertTrue(GrouperClientWs.mostRecentRequest,
34386           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
34387       assertTrue(GrouperClientWs.mostRecentRequest,
34388           !GrouperClientWs.mostRecentRequest.contains("params"));
34389       assertTrue(GrouperClientWs.mostRecentRequest,
34390           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
34391       assertTrue(GrouperClientWs.mostRecentRequest,
34392           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
34393       assertTrue(GrouperClientWs.mostRecentRequest,
34394           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups") && GrouperClientWs.mostRecentRequest.contains("<uuid>"));
34395       assertTrue(GrouperClientWs.mostRecentRequest,
34396           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
34397       assertTrue(GrouperClientWs.mostRecentRequest,
34398           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
34399       assertTrue(GrouperClientWs.mostRecentRequest,
34400           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
34401       assertTrue(GrouperClientWs.mostRecentRequest,
34402           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
34403       assertTrue(GrouperClientWs.mostRecentRequest,
34404           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
34405       assertTrue(GrouperClientWs.mostRecentRequest,
34406           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
34407       assertTrue(GrouperClientWs.mostRecentRequest,
34408           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
34409       assertFalse(GrouperClientWs.mostRecentRequest,
34410           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
34411       assertFalse(GrouperClientWs.mostRecentRequest,
34412           GrouperClientWs.mostRecentRequest.contains("theValue"));
34413       assertFalse(GrouperClientWs.mostRecentRequest,
34414           GrouperClientWs.mostRecentRequest.contains(">123<"));
34415       assertTrue(GrouperClientWs.mostRecentRequest,
34416           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
34417       assertFalse(GrouperClientWs.mostRecentRequest,
34418           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
34419       assertTrue(GrouperClientWs.mostRecentRequest,
34420           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
34421       assertTrue(GrouperClientWs.mostRecentRequest,
34422           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
34423       assertTrue(GrouperClientWs.mostRecentRequest,
34424           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
34425       assertTrue(GrouperClientWs.mostRecentRequest,
34426           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
34427       assertTrue(GrouperClientWs.mostRecentRequest,
34428           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
34429       assertTrue(GrouperClientWs.mostRecentRequest,
34430           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
34431 
34432 
34433       // ######################################################
34434       // Try group assignment on assignment by owner attribute assign id with wrong id
34435 
34436       baos = new ByteArrayOutputStream();
34437       System.setOut(new PrintStream(baos));
34438 
34439       try {
34440         GrouperClient.main(GrouperClientUtils.splitTrim(
34441             "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --assignAssignOwnerAttributeAssignUuids=1" + attributeAssign.getId()
34442             ,
34443           " "));
34444 
34445         System.out.flush();
34446         output = new String(baos.toByteArray());
34447 
34448         System.setOut(systemOut);
34449 
34450         outputLines = GrouperClientUtils.splitTrim(output, "\n");
34451 
34452         // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
34453         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
34454         pattern = Pattern
34455             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
34456 
34457         assertEquals(0, GrouperUtil.length(outputLines));
34458         fail("Shouldnt get here");
34459       } catch (Exception e) {
34460         //good
34461       } finally {
34462         System.setOut(systemOut);
34463 
34464       }
34465 
34466       assertTrue(GrouperClientWs.mostRecentRequest,
34467           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
34468       assertTrue(GrouperClientWs.mostRecentRequest,
34469           !GrouperClientWs.mostRecentRequest.contains("actions"));
34470       assertTrue(GrouperClientWs.mostRecentRequest,
34471           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
34472       assertTrue(GrouperClientWs.mostRecentRequest,
34473           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
34474       assertTrue(GrouperClientWs.mostRecentRequest,
34475           !GrouperClientWs.mostRecentRequest.contains("enabled"));
34476       assertTrue(GrouperClientWs.mostRecentRequest,
34477           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
34478       assertTrue(GrouperClientWs.mostRecentRequest,
34479           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
34480       assertTrue(GrouperClientWs.mostRecentRequest,
34481           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
34482       assertTrue(GrouperClientWs.mostRecentRequest,
34483           !GrouperClientWs.mostRecentRequest.contains("params"));
34484       assertTrue(GrouperClientWs.mostRecentRequest,
34485           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
34486       assertTrue(GrouperClientWs.mostRecentRequest,
34487           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
34488       assertFalse(GrouperClientWs.mostRecentRequest,
34489           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
34490       assertTrue(GrouperClientWs.mostRecentRequest,
34491           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
34492       assertTrue(GrouperClientWs.mostRecentRequest,
34493           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
34494       assertTrue(GrouperClientWs.mostRecentRequest,
34495           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
34496       assertTrue(GrouperClientWs.mostRecentRequest,
34497           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
34498       assertTrue(GrouperClientWs.mostRecentRequest,
34499           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
34500       assertTrue(GrouperClientWs.mostRecentRequest,
34501           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
34502       assertTrue(GrouperClientWs.mostRecentRequest,
34503           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
34504       assertTrue(GrouperClientWs.mostRecentRequest,
34505           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
34506       assertFalse(GrouperClientWs.mostRecentRequest,
34507           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
34508       assertFalse(GrouperClientWs.mostRecentRequest,
34509           GrouperClientWs.mostRecentRequest.contains("theValue"));
34510       assertFalse(GrouperClientWs.mostRecentRequest,
34511           GrouperClientWs.mostRecentRequest.contains(">123<"));
34512       assertFalse(GrouperClientWs.mostRecentRequest,
34513           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
34514       assertFalse(GrouperClientWs.mostRecentRequest,
34515           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
34516       assertTrue(GrouperClientWs.mostRecentRequest,
34517           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
34518       assertTrue(GrouperClientWs.mostRecentRequest,
34519           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
34520       assertTrue(GrouperClientWs.mostRecentRequest,
34521           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
34522       assertTrue(GrouperClientWs.mostRecentRequest,
34523           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
34524       assertTrue(GrouperClientWs.mostRecentRequest,
34525           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
34526       assertTrue(GrouperClientWs.mostRecentRequest,
34527           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
34528 
34529       // ######################################################
34530       // Try group assignment on assignment by owner attribute assign id
34531 
34532       baos = new ByteArrayOutputStream();
34533       System.setOut(new PrintStream(baos));
34534 
34535       GrouperClient.main(GrouperClientUtils.splitTrim(
34536           "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --assignAssignOwnerAttributeAssignUuids=" + attributeAssign.getId()
34537           ,
34538         " "));
34539 
34540       System.out.flush();
34541       output = new String(baos.toByteArray());
34542 
34543       System.setOut(systemOut);
34544 
34545       outputLines = GrouperClientUtils.splitTrim(output, "\n");
34546 
34547       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
34548       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
34549       pattern = Pattern
34550           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
34551 
34552       assertEquals(1, GrouperUtil.length(outputLines));
34553 
34554       outputLine = outputLines[0];
34555 
34556       matcher = pattern.matcher(outputLine);
34557 
34558       assertTrue(outputLine, matcher.matches());
34559       assertEquals(outputLine, "0", matcher.group(1));
34560       assertEquals(outputLine, "any_mem_asgn", matcher.group(2));
34561       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
34562       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
34563       assertEquals(outputLine, "assign", matcher.group(5));
34564       assertEquals(outputLine, "123", matcher.group(6));
34565       assertEquals(outputLine, "T", matcher.group(7));
34566       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
34567 
34568       assertTrue(GrouperClientWs.mostRecentRequest,
34569           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
34570       assertTrue(GrouperClientWs.mostRecentRequest,
34571           !GrouperClientWs.mostRecentRequest.contains("actions"));
34572       assertTrue(GrouperClientWs.mostRecentRequest,
34573           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
34574       assertTrue(GrouperClientWs.mostRecentRequest,
34575           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
34576       assertTrue(GrouperClientWs.mostRecentRequest,
34577           !GrouperClientWs.mostRecentRequest.contains("enabled"));
34578       assertTrue(GrouperClientWs.mostRecentRequest,
34579           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
34580       assertTrue(GrouperClientWs.mostRecentRequest,
34581           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
34582       assertTrue(GrouperClientWs.mostRecentRequest,
34583           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
34584       assertTrue(GrouperClientWs.mostRecentRequest,
34585           !GrouperClientWs.mostRecentRequest.contains("params"));
34586       assertTrue(GrouperClientWs.mostRecentRequest,
34587           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
34588       assertTrue(GrouperClientWs.mostRecentRequest,
34589           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
34590       assertFalse(GrouperClientWs.mostRecentRequest,
34591           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
34592       assertTrue(GrouperClientWs.mostRecentRequest,
34593           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
34594       assertTrue(GrouperClientWs.mostRecentRequest,
34595           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
34596       assertTrue(GrouperClientWs.mostRecentRequest,
34597           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
34598       assertTrue(GrouperClientWs.mostRecentRequest,
34599           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
34600       assertTrue(GrouperClientWs.mostRecentRequest,
34601           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
34602       assertTrue(GrouperClientWs.mostRecentRequest,
34603           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
34604       assertTrue(GrouperClientWs.mostRecentRequest,
34605           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
34606       assertTrue(GrouperClientWs.mostRecentRequest,
34607           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
34608       assertFalse(GrouperClientWs.mostRecentRequest,
34609           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
34610       assertFalse(GrouperClientWs.mostRecentRequest,
34611           GrouperClientWs.mostRecentRequest.contains("theValue"));
34612       assertFalse(GrouperClientWs.mostRecentRequest,
34613           GrouperClientWs.mostRecentRequest.contains(">123<"));
34614       assertFalse(GrouperClientWs.mostRecentRequest,
34615           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
34616       assertFalse(GrouperClientWs.mostRecentRequest,
34617           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
34618       assertTrue(GrouperClientWs.mostRecentRequest,
34619           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
34620       assertTrue(GrouperClientWs.mostRecentRequest,
34621           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
34622       assertTrue(GrouperClientWs.mostRecentRequest,
34623           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
34624       assertTrue(GrouperClientWs.mostRecentRequest,
34625           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
34626       assertTrue(GrouperClientWs.mostRecentRequest,
34627           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
34628       assertTrue(GrouperClientWs.mostRecentRequest,
34629           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
34630 
34631 
34632       // ######################################################
34633       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefLookups
34634 
34635       baos = new ByteArrayOutputStream();
34636       System.setOut(new PrintStream(baos));
34637 
34638       GrouperClient.main(GrouperClientUtils.splitTrim(
34639           "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --assignAssignOwnerNamesOfAttributeDefs=" + attributeDef.getName()
34640           ,
34641         " "));
34642 
34643       System.out.flush();
34644       output = new String(baos.toByteArray());
34645 
34646       System.setOut(systemOut);
34647 
34648       outputLines = GrouperClientUtils.splitTrim(output, "\n");
34649 
34650       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
34651       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
34652       pattern = Pattern
34653           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
34654 
34655       assertEquals(1, GrouperUtil.length(outputLines));
34656 
34657       outputLine = outputLines[0];
34658 
34659       matcher = pattern.matcher(outputLine);
34660 
34661       assertTrue(outputLine, matcher.matches());
34662       assertEquals(outputLine, "0", matcher.group(1));
34663       assertEquals(outputLine, "any_mem_asgn", matcher.group(2));
34664       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
34665       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
34666       assertEquals(outputLine, "assign", matcher.group(5));
34667       assertEquals(outputLine, "123", matcher.group(6));
34668       assertEquals(outputLine, "T", matcher.group(7));
34669       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
34670 
34671       assertTrue(GrouperClientWs.mostRecentRequest,
34672           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
34673       assertTrue(GrouperClientWs.mostRecentRequest,
34674           !GrouperClientWs.mostRecentRequest.contains("actions"));
34675       assertTrue(GrouperClientWs.mostRecentRequest,
34676           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
34677       assertTrue(GrouperClientWs.mostRecentRequest,
34678           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
34679       assertTrue(GrouperClientWs.mostRecentRequest,
34680           !GrouperClientWs.mostRecentRequest.contains("enabled"));
34681       assertTrue(GrouperClientWs.mostRecentRequest,
34682           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
34683       assertTrue(GrouperClientWs.mostRecentRequest,
34684           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
34685       assertTrue(GrouperClientWs.mostRecentRequest,
34686           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
34687       assertTrue(GrouperClientWs.mostRecentRequest,
34688           !GrouperClientWs.mostRecentRequest.contains("params"));
34689       assertTrue(GrouperClientWs.mostRecentRequest,
34690           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
34691       assertTrue(GrouperClientWs.mostRecentRequest,
34692           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
34693       assertFalse(GrouperClientWs.mostRecentRequest,
34694           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
34695       assertFalse(GrouperClientWs.mostRecentRequest,
34696           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
34697       assertTrue(GrouperClientWs.mostRecentRequest,
34698           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
34699       assertTrue(GrouperClientWs.mostRecentRequest,
34700           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
34701       assertTrue(GrouperClientWs.mostRecentRequest,
34702           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
34703       assertTrue(GrouperClientWs.mostRecentRequest,
34704           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
34705       assertTrue(GrouperClientWs.mostRecentRequest,
34706           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
34707       assertTrue(GrouperClientWs.mostRecentRequest,
34708           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
34709       assertTrue(GrouperClientWs.mostRecentRequest,
34710           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
34711       assertFalse(GrouperClientWs.mostRecentRequest,
34712           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
34713       assertFalse(GrouperClientWs.mostRecentRequest,
34714           GrouperClientWs.mostRecentRequest.contains("theValue"));
34715       assertFalse(GrouperClientWs.mostRecentRequest,
34716           GrouperClientWs.mostRecentRequest.contains(">123<"));
34717       assertFalse(GrouperClientWs.mostRecentRequest,
34718           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
34719       assertFalse(GrouperClientWs.mostRecentRequest,
34720           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
34721       assertTrue(GrouperClientWs.mostRecentRequest,
34722           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
34723       assertTrue(GrouperClientWs.mostRecentRequest,
34724           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
34725       assertTrue(GrouperClientWs.mostRecentRequest,
34726           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
34727       assertTrue(GrouperClientWs.mostRecentRequest,
34728           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
34729       assertTrue(GrouperClientWs.mostRecentRequest,
34730           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
34731       assertTrue(GrouperClientWs.mostRecentRequest,
34732           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
34733 
34734 
34735 
34736       // ######################################################
34737       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefLookups with wrong name
34738 
34739       baos = new ByteArrayOutputStream();
34740       System.setOut(new PrintStream(baos));
34741 
34742       try {
34743         GrouperClient.main(GrouperClientUtils.splitTrim(
34744             "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --assignAssignOwnerNamesOfAttributeDefs=1" + attributeDef.getName()
34745             ,
34746           " "));
34747 
34748         System.out.flush();
34749         output = new String(baos.toByteArray());
34750 
34751         System.setOut(systemOut);
34752 
34753         outputLines = GrouperClientUtils.splitTrim(output, "\n");
34754 
34755         // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
34756         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
34757         pattern = Pattern
34758             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
34759 
34760         assertEquals(0, GrouperUtil.length(outputLines));
34761 
34762         fail("shouldnt get here");
34763       } catch (Exception e) {
34764         //good
34765       } finally {
34766         System.setOut(systemOut);
34767       }
34768 
34769       assertTrue(GrouperClientWs.mostRecentRequest,
34770           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
34771       assertTrue(GrouperClientWs.mostRecentRequest,
34772           !GrouperClientWs.mostRecentRequest.contains("actions"));
34773       assertTrue(GrouperClientWs.mostRecentRequest,
34774           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
34775       assertTrue(GrouperClientWs.mostRecentRequest,
34776           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
34777       assertTrue(GrouperClientWs.mostRecentRequest,
34778           !GrouperClientWs.mostRecentRequest.contains("enabled"));
34779       assertTrue(GrouperClientWs.mostRecentRequest,
34780           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
34781       assertTrue(GrouperClientWs.mostRecentRequest,
34782           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
34783       assertTrue(GrouperClientWs.mostRecentRequest,
34784           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
34785       assertTrue(GrouperClientWs.mostRecentRequest,
34786           !GrouperClientWs.mostRecentRequest.contains("params"));
34787       assertTrue(GrouperClientWs.mostRecentRequest,
34788           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
34789       assertTrue(GrouperClientWs.mostRecentRequest,
34790           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
34791       assertFalse(GrouperClientWs.mostRecentRequest,
34792           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
34793       assertFalse(GrouperClientWs.mostRecentRequest,
34794           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
34795       assertTrue(GrouperClientWs.mostRecentRequest,
34796           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
34797       assertTrue(GrouperClientWs.mostRecentRequest,
34798           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
34799       assertTrue(GrouperClientWs.mostRecentRequest,
34800           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
34801       assertTrue(GrouperClientWs.mostRecentRequest,
34802           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
34803       assertTrue(GrouperClientWs.mostRecentRequest,
34804           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
34805       assertTrue(GrouperClientWs.mostRecentRequest,
34806           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
34807       assertTrue(GrouperClientWs.mostRecentRequest,
34808           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
34809       assertFalse(GrouperClientWs.mostRecentRequest,
34810           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
34811       assertFalse(GrouperClientWs.mostRecentRequest,
34812           GrouperClientWs.mostRecentRequest.contains("theValue"));
34813       assertFalse(GrouperClientWs.mostRecentRequest,
34814           GrouperClientWs.mostRecentRequest.contains(">123<"));
34815       assertFalse(GrouperClientWs.mostRecentRequest,
34816           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
34817       assertFalse(GrouperClientWs.mostRecentRequest,
34818           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
34819       assertTrue(GrouperClientWs.mostRecentRequest,
34820           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
34821       assertTrue(GrouperClientWs.mostRecentRequest,
34822           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
34823       assertTrue(GrouperClientWs.mostRecentRequest,
34824           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
34825       assertTrue(GrouperClientWs.mostRecentRequest,
34826           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
34827       assertTrue(GrouperClientWs.mostRecentRequest,
34828           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
34829       assertTrue(GrouperClientWs.mostRecentRequest,
34830           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
34831 
34832 
34833       // ######################################################
34834       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefLookups
34835 
34836       baos = new ByteArrayOutputStream();
34837       System.setOut(new PrintStream(baos));
34838 
34839       GrouperClient.main(GrouperClientUtils.splitTrim(
34840           "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --assignAssignOwnerUuidsOfAttributeDefs=" + attributeDef.getId()
34841           ,
34842         " "));
34843 
34844       System.out.flush();
34845       output = new String(baos.toByteArray());
34846 
34847       System.setOut(systemOut);
34848 
34849       outputLines = GrouperClientUtils.splitTrim(output, "\n");
34850 
34851       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
34852       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
34853       pattern = Pattern
34854           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
34855 
34856       assertEquals(1, GrouperUtil.length(outputLines));
34857 
34858       outputLine = outputLines[0];
34859 
34860       matcher = pattern.matcher(outputLine);
34861 
34862       assertTrue(outputLine, matcher.matches());
34863       assertEquals(outputLine, "0", matcher.group(1));
34864       assertEquals(outputLine, "any_mem_asgn", matcher.group(2));
34865       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
34866       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
34867       assertEquals(outputLine, "assign", matcher.group(5));
34868       assertEquals(outputLine, "123", matcher.group(6));
34869       assertEquals(outputLine, "T", matcher.group(7));
34870       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
34871 
34872       assertTrue(GrouperClientWs.mostRecentRequest,
34873           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
34874       assertTrue(GrouperClientWs.mostRecentRequest,
34875           !GrouperClientWs.mostRecentRequest.contains("actions"));
34876       assertTrue(GrouperClientWs.mostRecentRequest,
34877           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
34878       assertTrue(GrouperClientWs.mostRecentRequest,
34879           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
34880       assertTrue(GrouperClientWs.mostRecentRequest,
34881           !GrouperClientWs.mostRecentRequest.contains("enabled"));
34882       assertTrue(GrouperClientWs.mostRecentRequest,
34883           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
34884       assertTrue(GrouperClientWs.mostRecentRequest,
34885           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
34886       assertTrue(GrouperClientWs.mostRecentRequest,
34887           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
34888       assertTrue(GrouperClientWs.mostRecentRequest,
34889           !GrouperClientWs.mostRecentRequest.contains("params"));
34890       assertTrue(GrouperClientWs.mostRecentRequest,
34891           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
34892       assertTrue(GrouperClientWs.mostRecentRequest,
34893           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
34894       assertFalse(GrouperClientWs.mostRecentRequest,
34895           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
34896       assertTrue(GrouperClientWs.mostRecentRequest,
34897           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
34898       assertTrue(GrouperClientWs.mostRecentRequest,
34899           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
34900       assertTrue(GrouperClientWs.mostRecentRequest,
34901           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
34902       assertTrue(GrouperClientWs.mostRecentRequest,
34903           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
34904       assertTrue(GrouperClientWs.mostRecentRequest,
34905           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
34906       assertTrue(GrouperClientWs.mostRecentRequest,
34907           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
34908       assertTrue(GrouperClientWs.mostRecentRequest,
34909           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
34910       assertTrue(GrouperClientWs.mostRecentRequest,
34911           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
34912       assertFalse(GrouperClientWs.mostRecentRequest,
34913           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
34914       assertFalse(GrouperClientWs.mostRecentRequest,
34915           GrouperClientWs.mostRecentRequest.contains("theValue"));
34916       assertFalse(GrouperClientWs.mostRecentRequest,
34917           GrouperClientWs.mostRecentRequest.contains(">123<"));
34918       assertFalse(GrouperClientWs.mostRecentRequest,
34919           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
34920       assertFalse(GrouperClientWs.mostRecentRequest,
34921           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
34922       assertTrue(GrouperClientWs.mostRecentRequest,
34923           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
34924       assertTrue(GrouperClientWs.mostRecentRequest,
34925           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
34926       assertTrue(GrouperClientWs.mostRecentRequest,
34927           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
34928       assertTrue(GrouperClientWs.mostRecentRequest,
34929           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
34930       assertTrue(GrouperClientWs.mostRecentRequest,
34931           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
34932       assertTrue(GrouperClientWs.mostRecentRequest,
34933           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
34934 
34935 
34936       // ######################################################
34937       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefLookups
34938 
34939       baos = new ByteArrayOutputStream();
34940       System.setOut(new PrintStream(baos));
34941 
34942       GrouperClient.main(GrouperClientUtils.splitTrim(
34943           "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --assignAssignOwnerUuidsOfAttributeDefs=" + attributeDef.getId()
34944           ,
34945         " "));
34946 
34947       System.out.flush();
34948       output = new String(baos.toByteArray());
34949 
34950       System.setOut(systemOut);
34951 
34952       outputLines = GrouperClientUtils.splitTrim(output, "\n");
34953 
34954       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
34955       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
34956       pattern = Pattern
34957           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
34958 
34959       assertEquals(1, GrouperUtil.length(outputLines));
34960 
34961       outputLine = outputLines[0];
34962 
34963       matcher = pattern.matcher(outputLine);
34964 
34965       assertTrue(outputLine, matcher.matches());
34966       assertEquals(outputLine, "0", matcher.group(1));
34967       assertEquals(outputLine, "any_mem_asgn", matcher.group(2));
34968       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
34969       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
34970       assertEquals(outputLine, "assign", matcher.group(5));
34971       assertEquals(outputLine, "123", matcher.group(6));
34972       assertEquals(outputLine, "T", matcher.group(7));
34973       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
34974 
34975       assertTrue(GrouperClientWs.mostRecentRequest,
34976           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
34977       assertTrue(GrouperClientWs.mostRecentRequest,
34978           !GrouperClientWs.mostRecentRequest.contains("actions"));
34979       assertTrue(GrouperClientWs.mostRecentRequest,
34980           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
34981       assertTrue(GrouperClientWs.mostRecentRequest,
34982           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
34983       assertTrue(GrouperClientWs.mostRecentRequest,
34984           !GrouperClientWs.mostRecentRequest.contains("enabled"));
34985       assertTrue(GrouperClientWs.mostRecentRequest,
34986           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
34987       assertTrue(GrouperClientWs.mostRecentRequest,
34988           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
34989       assertTrue(GrouperClientWs.mostRecentRequest,
34990           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
34991       assertTrue(GrouperClientWs.mostRecentRequest,
34992           !GrouperClientWs.mostRecentRequest.contains("params"));
34993       assertTrue(GrouperClientWs.mostRecentRequest,
34994           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
34995       assertTrue(GrouperClientWs.mostRecentRequest,
34996           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
34997       assertFalse(GrouperClientWs.mostRecentRequest,
34998           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
34999       assertTrue(GrouperClientWs.mostRecentRequest,
35000           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
35001       assertTrue(GrouperClientWs.mostRecentRequest,
35002           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
35003       assertTrue(GrouperClientWs.mostRecentRequest,
35004           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
35005       assertTrue(GrouperClientWs.mostRecentRequest,
35006           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
35007       assertTrue(GrouperClientWs.mostRecentRequest,
35008           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
35009       assertTrue(GrouperClientWs.mostRecentRequest,
35010           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
35011       assertTrue(GrouperClientWs.mostRecentRequest,
35012           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
35013       assertTrue(GrouperClientWs.mostRecentRequest,
35014           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
35015       assertFalse(GrouperClientWs.mostRecentRequest,
35016           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
35017       assertFalse(GrouperClientWs.mostRecentRequest,
35018           GrouperClientWs.mostRecentRequest.contains("theValue"));
35019       assertFalse(GrouperClientWs.mostRecentRequest,
35020           GrouperClientWs.mostRecentRequest.contains(">123<"));
35021       assertFalse(GrouperClientWs.mostRecentRequest,
35022           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
35023       assertFalse(GrouperClientWs.mostRecentRequest,
35024           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
35025       assertTrue(GrouperClientWs.mostRecentRequest,
35026           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
35027       assertTrue(GrouperClientWs.mostRecentRequest,
35028           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
35029       assertTrue(GrouperClientWs.mostRecentRequest,
35030           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
35031       assertTrue(GrouperClientWs.mostRecentRequest,
35032           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
35033       assertTrue(GrouperClientWs.mostRecentRequest,
35034           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
35035       assertTrue(GrouperClientWs.mostRecentRequest,
35036           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
35037 
35038 
35039 
35040       // ######################################################
35041       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefLookups
35042 
35043       baos = new ByteArrayOutputStream();
35044       System.setOut(new PrintStream(baos));
35045 
35046       try {
35047         GrouperClient.main(GrouperClientUtils.splitTrim(
35048             "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --assignAssignOwnerUuidsOfAttributeDefs=1" + attributeDef.getId()
35049             ,
35050           " "));
35051 
35052         System.out.flush();
35053         output = new String(baos.toByteArray());
35054 
35055         System.setOut(systemOut);
35056 
35057         outputLines = GrouperClientUtils.splitTrim(output, "\n");
35058 
35059         // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
35060         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
35061         pattern = Pattern
35062             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
35063 
35064         assertEquals(0, GrouperUtil.length(outputLines));
35065         fail("Shouldnt get here");
35066       } catch (Exception e) {
35067         //good
35068       } finally {
35069 
35070         System.setOut(systemOut);
35071 
35072       }
35073 
35074       assertTrue(GrouperClientWs.mostRecentRequest,
35075           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
35076       assertTrue(GrouperClientWs.mostRecentRequest,
35077           !GrouperClientWs.mostRecentRequest.contains("actions"));
35078       assertTrue(GrouperClientWs.mostRecentRequest,
35079           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
35080       assertTrue(GrouperClientWs.mostRecentRequest,
35081           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
35082       assertTrue(GrouperClientWs.mostRecentRequest,
35083           !GrouperClientWs.mostRecentRequest.contains("enabled"));
35084       assertTrue(GrouperClientWs.mostRecentRequest,
35085           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
35086       assertTrue(GrouperClientWs.mostRecentRequest,
35087           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
35088       assertTrue(GrouperClientWs.mostRecentRequest,
35089           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
35090       assertTrue(GrouperClientWs.mostRecentRequest,
35091           !GrouperClientWs.mostRecentRequest.contains("params"));
35092       assertTrue(GrouperClientWs.mostRecentRequest,
35093           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
35094       assertTrue(GrouperClientWs.mostRecentRequest,
35095           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
35096       assertFalse(GrouperClientWs.mostRecentRequest,
35097           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
35098       assertTrue(GrouperClientWs.mostRecentRequest,
35099           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
35100       assertTrue(GrouperClientWs.mostRecentRequest,
35101           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
35102       assertTrue(GrouperClientWs.mostRecentRequest,
35103           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
35104       assertTrue(GrouperClientWs.mostRecentRequest,
35105           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
35106       assertTrue(GrouperClientWs.mostRecentRequest,
35107           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
35108       assertTrue(GrouperClientWs.mostRecentRequest,
35109           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
35110       assertTrue(GrouperClientWs.mostRecentRequest,
35111           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
35112       assertTrue(GrouperClientWs.mostRecentRequest,
35113           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
35114       assertFalse(GrouperClientWs.mostRecentRequest,
35115           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
35116       assertFalse(GrouperClientWs.mostRecentRequest,
35117           GrouperClientWs.mostRecentRequest.contains("theValue"));
35118       assertFalse(GrouperClientWs.mostRecentRequest,
35119           GrouperClientWs.mostRecentRequest.contains(">123<"));
35120       assertFalse(GrouperClientWs.mostRecentRequest,
35121           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
35122       assertFalse(GrouperClientWs.mostRecentRequest,
35123           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
35124       assertTrue(GrouperClientWs.mostRecentRequest,
35125           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
35126       assertTrue(GrouperClientWs.mostRecentRequest,
35127           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
35128       assertTrue(GrouperClientWs.mostRecentRequest,
35129           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefs"));
35130       assertTrue(GrouperClientWs.mostRecentRequest,
35131           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
35132       assertTrue(GrouperClientWs.mostRecentRequest,
35133           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerUuidsOfAttributeDefNames"));
35134       assertTrue(GrouperClientWs.mostRecentRequest,
35135           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
35136 
35137 
35138       // ######################################################
35139       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups
35140 
35141       baos = new ByteArrayOutputStream();
35142       System.setOut(new PrintStream(baos));
35143 
35144       GrouperClient.main(GrouperClientUtils.splitTrim(
35145           "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --assignAssignOwnerNamesOfAttributeDefNames=" + attributeDefName.getName()
35146           ,
35147         " "));
35148 
35149       System.out.flush();
35150       output = new String(baos.toByteArray());
35151 
35152       System.setOut(systemOut);
35153 
35154       outputLines = GrouperClientUtils.splitTrim(output, "\n");
35155 
35156       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
35157       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
35158       pattern = Pattern
35159           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
35160 
35161       assertEquals(1, GrouperUtil.length(outputLines));
35162 
35163       outputLine = outputLines[0];
35164 
35165       matcher = pattern.matcher(outputLine);
35166 
35167       assertTrue(outputLine, matcher.matches());
35168       assertEquals(outputLine, "0", matcher.group(1));
35169       assertEquals(outputLine, "any_mem_asgn", matcher.group(2));
35170       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
35171       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
35172       assertEquals(outputLine, "assign", matcher.group(5));
35173       assertEquals(outputLine, "123", matcher.group(6));
35174       assertEquals(outputLine, "T", matcher.group(7));
35175       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
35176 
35177       assertTrue(GrouperClientWs.mostRecentRequest,
35178           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
35179       assertTrue(GrouperClientWs.mostRecentRequest,
35180           !GrouperClientWs.mostRecentRequest.contains("actions"));
35181       assertTrue(GrouperClientWs.mostRecentRequest,
35182           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
35183       assertTrue(GrouperClientWs.mostRecentRequest,
35184           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
35185       assertTrue(GrouperClientWs.mostRecentRequest,
35186           !GrouperClientWs.mostRecentRequest.contains("enabled"));
35187       assertTrue(GrouperClientWs.mostRecentRequest,
35188           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
35189       assertTrue(GrouperClientWs.mostRecentRequest,
35190           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
35191       assertTrue(GrouperClientWs.mostRecentRequest,
35192           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
35193       assertTrue(GrouperClientWs.mostRecentRequest,
35194           !GrouperClientWs.mostRecentRequest.contains("params"));
35195       assertTrue(GrouperClientWs.mostRecentRequest,
35196           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
35197       assertTrue(GrouperClientWs.mostRecentRequest,
35198           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
35199       assertFalse(GrouperClientWs.mostRecentRequest,
35200           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
35201       assertFalse(GrouperClientWs.mostRecentRequest,
35202           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
35203       assertTrue(GrouperClientWs.mostRecentRequest,
35204           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
35205       assertTrue(GrouperClientWs.mostRecentRequest,
35206           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
35207       assertTrue(GrouperClientWs.mostRecentRequest,
35208           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
35209       assertTrue(GrouperClientWs.mostRecentRequest,
35210           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
35211       assertTrue(GrouperClientWs.mostRecentRequest,
35212           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
35213       assertTrue(GrouperClientWs.mostRecentRequest,
35214           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
35215       assertTrue(GrouperClientWs.mostRecentRequest,
35216           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
35217       assertFalse(GrouperClientWs.mostRecentRequest,
35218           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
35219       assertFalse(GrouperClientWs.mostRecentRequest,
35220           GrouperClientWs.mostRecentRequest.contains("theValue"));
35221       assertFalse(GrouperClientWs.mostRecentRequest,
35222           GrouperClientWs.mostRecentRequest.contains(">123<"));
35223       assertFalse(GrouperClientWs.mostRecentRequest,
35224           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
35225       assertFalse(GrouperClientWs.mostRecentRequest,
35226           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
35227       assertTrue(GrouperClientWs.mostRecentRequest,
35228           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
35229       assertTrue(GrouperClientWs.mostRecentRequest,
35230           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
35231       assertTrue(GrouperClientWs.mostRecentRequest,
35232           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
35233       assertTrue(GrouperClientWs.mostRecentRequest,
35234           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
35235 
35236 
35237 
35238       // ######################################################
35239       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups
35240 
35241       baos = new ByteArrayOutputStream();
35242       System.setOut(new PrintStream(baos));
35243 
35244       try {
35245         GrouperClient.main(GrouperClientUtils.splitTrim(
35246             "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --assignAssignOwnerNamesOfAttributeDefNames=1" + attributeDefName.getName()
35247             ,
35248           " "));
35249 
35250         System.out.flush();
35251         output = new String(baos.toByteArray());
35252 
35253         System.setOut(systemOut);
35254 
35255         outputLines = GrouperClientUtils.splitTrim(output, "\n");
35256 
35257         // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
35258         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
35259         pattern = Pattern
35260             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
35261 
35262         assertEquals(0, GrouperUtil.length(outputLines));
35263         fail("Shouldnt get here");
35264 
35265       } catch (Exception e) {
35266         //ok
35267       } finally {
35268 
35269         System.setOut(systemOut);
35270 
35271       }
35272 
35273       assertTrue(GrouperClientWs.mostRecentRequest,
35274           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
35275       assertTrue(GrouperClientWs.mostRecentRequest,
35276           !GrouperClientWs.mostRecentRequest.contains("actions"));
35277       assertTrue(GrouperClientWs.mostRecentRequest,
35278           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
35279       assertTrue(GrouperClientWs.mostRecentRequest,
35280           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
35281       assertTrue(GrouperClientWs.mostRecentRequest,
35282           !GrouperClientWs.mostRecentRequest.contains("enabled"));
35283       assertTrue(GrouperClientWs.mostRecentRequest,
35284           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
35285       assertTrue(GrouperClientWs.mostRecentRequest,
35286           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
35287       assertTrue(GrouperClientWs.mostRecentRequest,
35288           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
35289       assertTrue(GrouperClientWs.mostRecentRequest,
35290           !GrouperClientWs.mostRecentRequest.contains("params"));
35291       assertTrue(GrouperClientWs.mostRecentRequest,
35292           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
35293       assertTrue(GrouperClientWs.mostRecentRequest,
35294           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
35295       assertFalse(GrouperClientWs.mostRecentRequest,
35296           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
35297       assertFalse(GrouperClientWs.mostRecentRequest,
35298           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
35299       assertTrue(GrouperClientWs.mostRecentRequest,
35300           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
35301       assertTrue(GrouperClientWs.mostRecentRequest,
35302           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
35303       assertTrue(GrouperClientWs.mostRecentRequest,
35304           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
35305       assertTrue(GrouperClientWs.mostRecentRequest,
35306           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
35307       assertTrue(GrouperClientWs.mostRecentRequest,
35308           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
35309       assertTrue(GrouperClientWs.mostRecentRequest,
35310           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
35311       assertTrue(GrouperClientWs.mostRecentRequest,
35312           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
35313       assertFalse(GrouperClientWs.mostRecentRequest,
35314           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
35315       assertFalse(GrouperClientWs.mostRecentRequest,
35316           GrouperClientWs.mostRecentRequest.contains("theValue"));
35317       assertFalse(GrouperClientWs.mostRecentRequest,
35318           GrouperClientWs.mostRecentRequest.contains(">123<"));
35319       assertFalse(GrouperClientWs.mostRecentRequest,
35320           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
35321       assertFalse(GrouperClientWs.mostRecentRequest,
35322           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
35323       assertTrue(GrouperClientWs.mostRecentRequest,
35324           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
35325       assertTrue(GrouperClientWs.mostRecentRequest,
35326           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
35327       assertTrue(GrouperClientWs.mostRecentRequest,
35328           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
35329       assertTrue(GrouperClientWs.mostRecentRequest,
35330           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
35331 
35332 
35333       // ######################################################
35334       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups
35335 
35336       baos = new ByteArrayOutputStream();
35337       System.setOut(new PrintStream(baos));
35338 
35339       GrouperClient.main(GrouperClientUtils.splitTrim(
35340           "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
35341           ,
35342         " "));
35343 
35344       System.out.flush();
35345       output = new String(baos.toByteArray());
35346 
35347       System.setOut(systemOut);
35348 
35349       outputLines = GrouperClientUtils.splitTrim(output, "\n");
35350 
35351       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
35352       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
35353       pattern = Pattern
35354           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
35355 
35356       assertEquals(1, GrouperUtil.length(outputLines));
35357 
35358       outputLine = outputLines[0];
35359 
35360       matcher = pattern.matcher(outputLine);
35361 
35362       assertTrue(outputLine, matcher.matches());
35363       assertEquals(outputLine, "0", matcher.group(1));
35364       assertEquals(outputLine, "any_mem_asgn", matcher.group(2));
35365       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
35366       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
35367       assertEquals(outputLine, "assign", matcher.group(5));
35368       assertEquals(outputLine, "123", matcher.group(6));
35369       assertEquals(outputLine, "T", matcher.group(7));
35370       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
35371 
35372       assertTrue(GrouperClientWs.mostRecentRequest,
35373           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
35374       assertTrue(GrouperClientWs.mostRecentRequest,
35375           !GrouperClientWs.mostRecentRequest.contains("actions"));
35376       assertTrue(GrouperClientWs.mostRecentRequest,
35377           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
35378       assertTrue(GrouperClientWs.mostRecentRequest,
35379           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
35380       assertTrue(GrouperClientWs.mostRecentRequest,
35381           !GrouperClientWs.mostRecentRequest.contains("enabled"));
35382       assertTrue(GrouperClientWs.mostRecentRequest,
35383           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
35384       assertTrue(GrouperClientWs.mostRecentRequest,
35385           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
35386       assertTrue(GrouperClientWs.mostRecentRequest,
35387           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
35388       assertTrue(GrouperClientWs.mostRecentRequest,
35389           !GrouperClientWs.mostRecentRequest.contains("params"));
35390       assertTrue(GrouperClientWs.mostRecentRequest,
35391           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
35392       assertTrue(GrouperClientWs.mostRecentRequest,
35393           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
35394       assertFalse(GrouperClientWs.mostRecentRequest,
35395           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
35396       assertTrue(GrouperClientWs.mostRecentRequest,
35397           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
35398       assertTrue(GrouperClientWs.mostRecentRequest,
35399           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
35400       assertTrue(GrouperClientWs.mostRecentRequest,
35401           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
35402       assertTrue(GrouperClientWs.mostRecentRequest,
35403           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
35404       assertTrue(GrouperClientWs.mostRecentRequest,
35405           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
35406       assertTrue(GrouperClientWs.mostRecentRequest,
35407           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
35408       assertTrue(GrouperClientWs.mostRecentRequest,
35409           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
35410       assertTrue(GrouperClientWs.mostRecentRequest,
35411           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
35412       assertFalse(GrouperClientWs.mostRecentRequest,
35413           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
35414       assertFalse(GrouperClientWs.mostRecentRequest,
35415           GrouperClientWs.mostRecentRequest.contains("theValue"));
35416       assertFalse(GrouperClientWs.mostRecentRequest,
35417           GrouperClientWs.mostRecentRequest.contains(">123<"));
35418       assertFalse(GrouperClientWs.mostRecentRequest,
35419           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
35420       assertFalse(GrouperClientWs.mostRecentRequest,
35421           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
35422       assertTrue(GrouperClientWs.mostRecentRequest,
35423           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
35424       assertTrue(GrouperClientWs.mostRecentRequest,
35425           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
35426       assertTrue(GrouperClientWs.mostRecentRequest,
35427           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
35428       assertTrue(GrouperClientWs.mostRecentRequest,
35429           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
35430 
35431 
35432 
35433       // ######################################################
35434       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups wrong name
35435 
35436       baos = new ByteArrayOutputStream();
35437       System.setOut(new PrintStream(baos));
35438 
35439       try {
35440         GrouperClient.main(GrouperClientUtils.splitTrim(
35441             "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --assignAssignOwnerUuidsOfAttributeDefNames=1" + attributeDefName.getId()
35442             ,
35443           " "));
35444 
35445         System.out.flush();
35446         output = new String(baos.toByteArray());
35447 
35448         System.setOut(systemOut);
35449 
35450         outputLines = GrouperClientUtils.splitTrim(output, "\n");
35451 
35452         // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
35453         // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
35454         pattern = Pattern
35455             .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
35456 
35457         assertEquals(1, GrouperUtil.length(outputLines));
35458         fail("Shouldnt get here");
35459       } catch (Exception e) {
35460         //good
35461       } finally {
35462 
35463         System.setOut(systemOut);
35464 
35465       }
35466 
35467       assertTrue(GrouperClientWs.mostRecentRequest,
35468           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
35469       assertTrue(GrouperClientWs.mostRecentRequest,
35470           !GrouperClientWs.mostRecentRequest.contains("actions"));
35471       assertTrue(GrouperClientWs.mostRecentRequest,
35472           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
35473       assertTrue(GrouperClientWs.mostRecentRequest,
35474           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
35475       assertTrue(GrouperClientWs.mostRecentRequest,
35476           !GrouperClientWs.mostRecentRequest.contains("enabled"));
35477       assertTrue(GrouperClientWs.mostRecentRequest,
35478           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
35479       assertTrue(GrouperClientWs.mostRecentRequest,
35480           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
35481       assertTrue(GrouperClientWs.mostRecentRequest,
35482           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
35483       assertTrue(GrouperClientWs.mostRecentRequest,
35484           !GrouperClientWs.mostRecentRequest.contains("params"));
35485       assertTrue(GrouperClientWs.mostRecentRequest,
35486           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
35487       assertTrue(GrouperClientWs.mostRecentRequest,
35488           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
35489       assertFalse(GrouperClientWs.mostRecentRequest,
35490           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
35491       assertTrue(GrouperClientWs.mostRecentRequest,
35492           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
35493       assertTrue(GrouperClientWs.mostRecentRequest,
35494           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
35495       assertTrue(GrouperClientWs.mostRecentRequest,
35496           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
35497       assertTrue(GrouperClientWs.mostRecentRequest,
35498           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
35499       assertTrue(GrouperClientWs.mostRecentRequest,
35500           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
35501       assertTrue(GrouperClientWs.mostRecentRequest,
35502           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
35503       assertTrue(GrouperClientWs.mostRecentRequest,
35504           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
35505       assertTrue(GrouperClientWs.mostRecentRequest,
35506           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
35507       assertFalse(GrouperClientWs.mostRecentRequest,
35508           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
35509       assertFalse(GrouperClientWs.mostRecentRequest,
35510           GrouperClientWs.mostRecentRequest.contains("theValue"));
35511       assertFalse(GrouperClientWs.mostRecentRequest,
35512           GrouperClientWs.mostRecentRequest.contains(">123<"));
35513       assertFalse(GrouperClientWs.mostRecentRequest,
35514           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
35515       assertFalse(GrouperClientWs.mostRecentRequest,
35516           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
35517       assertTrue(GrouperClientWs.mostRecentRequest,
35518           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
35519       assertTrue(GrouperClientWs.mostRecentRequest,
35520           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
35521       assertTrue(GrouperClientWs.mostRecentRequest,
35522           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
35523       assertTrue(GrouperClientWs.mostRecentRequest,
35524           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerActions"));
35525 
35526 
35527       // ######################################################
35528       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups
35529 
35530       baos = new ByteArrayOutputStream();
35531       System.setOut(new PrintStream(baos));
35532 
35533       GrouperClient.main(GrouperClientUtils.splitTrim(
35534           "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
35535           + " --assignAssignOwnerActions=assign",
35536         " "));
35537 
35538       System.out.flush();
35539       output = new String(baos.toByteArray());
35540 
35541       System.setOut(systemOut);
35542 
35543       outputLines = GrouperClientUtils.splitTrim(output, "\n");
35544 
35545       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
35546       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
35547       pattern = Pattern
35548           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
35549 
35550       assertEquals(1, GrouperUtil.length(outputLines));
35551 
35552       outputLine = outputLines[0];
35553 
35554       matcher = pattern.matcher(outputLine);
35555 
35556       assertTrue(outputLine, matcher.matches());
35557       assertEquals(outputLine, "0", matcher.group(1));
35558       assertEquals(outputLine, "any_mem_asgn", matcher.group(2));
35559       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
35560       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
35561       assertEquals(outputLine, "assign", matcher.group(5));
35562       assertEquals(outputLine, "123", matcher.group(6));
35563       assertEquals(outputLine, "T", matcher.group(7));
35564       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
35565 
35566       assertTrue(GrouperClientWs.mostRecentRequest,
35567           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
35568       assertTrue(GrouperClientWs.mostRecentRequest,
35569           !GrouperClientWs.mostRecentRequest.contains("<actions>"));
35570       assertTrue(GrouperClientWs.mostRecentRequest,
35571           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
35572       assertTrue(GrouperClientWs.mostRecentRequest,
35573           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
35574       assertTrue(GrouperClientWs.mostRecentRequest,
35575           !GrouperClientWs.mostRecentRequest.contains("enabled"));
35576       assertTrue(GrouperClientWs.mostRecentRequest,
35577           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
35578       assertTrue(GrouperClientWs.mostRecentRequest,
35579           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
35580       assertTrue(GrouperClientWs.mostRecentRequest,
35581           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
35582       assertTrue(GrouperClientWs.mostRecentRequest,
35583           !GrouperClientWs.mostRecentRequest.contains("params"));
35584       assertTrue(GrouperClientWs.mostRecentRequest,
35585           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
35586       assertTrue(GrouperClientWs.mostRecentRequest,
35587           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
35588       assertFalse(GrouperClientWs.mostRecentRequest,
35589           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
35590       assertTrue(GrouperClientWs.mostRecentRequest,
35591           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
35592       assertTrue(GrouperClientWs.mostRecentRequest,
35593           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
35594       assertTrue(GrouperClientWs.mostRecentRequest,
35595           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
35596       assertTrue(GrouperClientWs.mostRecentRequest,
35597           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
35598       assertTrue(GrouperClientWs.mostRecentRequest,
35599           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
35600       assertTrue(GrouperClientWs.mostRecentRequest,
35601           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
35602       assertTrue(GrouperClientWs.mostRecentRequest,
35603           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
35604       assertTrue(GrouperClientWs.mostRecentRequest,
35605           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
35606       assertFalse(GrouperClientWs.mostRecentRequest,
35607           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
35608       assertFalse(GrouperClientWs.mostRecentRequest,
35609           GrouperClientWs.mostRecentRequest.contains("theValue"));
35610       assertFalse(GrouperClientWs.mostRecentRequest,
35611           GrouperClientWs.mostRecentRequest.contains(">123<"));
35612       assertFalse(GrouperClientWs.mostRecentRequest,
35613           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
35614       assertFalse(GrouperClientWs.mostRecentRequest,
35615           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
35616       assertTrue(GrouperClientWs.mostRecentRequest,
35617           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
35618       assertTrue(GrouperClientWs.mostRecentRequest,
35619           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
35620       assertTrue(GrouperClientWs.mostRecentRequest,
35621           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
35622       assertTrue(GrouperClientWs.mostRecentRequest,
35623           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
35624 
35625 
35626       // ######################################################
35627       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups wrong action
35628 
35629       baos = new ByteArrayOutputStream();
35630       System.setOut(new PrintStream(baos));
35631 
35632       GrouperClient.main(GrouperClientUtils.splitTrim(
35633           "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --assignAssignOwnerUuidsOfAttributeDefNames=" + attributeDefName.getId()
35634           + " --assignAssignOwnerActions=assign2",
35635         " "));
35636 
35637       System.out.flush();
35638       output = new String(baos.toByteArray());
35639 
35640       System.setOut(systemOut);
35641 
35642       outputLines = GrouperClientUtils.splitTrim(output, "\n");
35643 
35644       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
35645       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
35646       pattern = Pattern
35647           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
35648 
35649       assertEquals(0, GrouperUtil.length(outputLines));
35650 
35651       assertTrue(GrouperClientWs.mostRecentRequest,
35652           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
35653       assertTrue(GrouperClientWs.mostRecentRequest,
35654           !GrouperClientWs.mostRecentRequest.contains("<actions>"));
35655       assertTrue(GrouperClientWs.mostRecentRequest,
35656           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
35657       assertTrue(GrouperClientWs.mostRecentRequest,
35658           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
35659       assertTrue(GrouperClientWs.mostRecentRequest,
35660           !GrouperClientWs.mostRecentRequest.contains("enabled"));
35661       assertTrue(GrouperClientWs.mostRecentRequest,
35662           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
35663       assertTrue(GrouperClientWs.mostRecentRequest,
35664           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
35665       assertTrue(GrouperClientWs.mostRecentRequest,
35666           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
35667       assertTrue(GrouperClientWs.mostRecentRequest,
35668           !GrouperClientWs.mostRecentRequest.contains("params"));
35669       assertTrue(GrouperClientWs.mostRecentRequest,
35670           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
35671       assertTrue(GrouperClientWs.mostRecentRequest,
35672           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
35673       assertFalse(GrouperClientWs.mostRecentRequest,
35674           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
35675       assertTrue(GrouperClientWs.mostRecentRequest,
35676           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
35677       assertTrue(GrouperClientWs.mostRecentRequest,
35678           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
35679       assertTrue(GrouperClientWs.mostRecentRequest,
35680           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
35681       assertTrue(GrouperClientWs.mostRecentRequest,
35682           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
35683       assertTrue(GrouperClientWs.mostRecentRequest,
35684           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
35685       assertTrue(GrouperClientWs.mostRecentRequest,
35686           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
35687       assertTrue(GrouperClientWs.mostRecentRequest,
35688           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
35689       assertTrue(GrouperClientWs.mostRecentRequest,
35690           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
35691       assertFalse(GrouperClientWs.mostRecentRequest,
35692           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
35693       assertFalse(GrouperClientWs.mostRecentRequest,
35694           GrouperClientWs.mostRecentRequest.contains("theValue"));
35695       assertFalse(GrouperClientWs.mostRecentRequest,
35696           GrouperClientWs.mostRecentRequest.contains(">123<"));
35697       assertFalse(GrouperClientWs.mostRecentRequest,
35698           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
35699       assertFalse(GrouperClientWs.mostRecentRequest,
35700           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
35701       assertTrue(GrouperClientWs.mostRecentRequest,
35702           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
35703       assertTrue(GrouperClientWs.mostRecentRequest,
35704           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
35705       assertTrue(GrouperClientWs.mostRecentRequest,
35706           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
35707       assertTrue(GrouperClientWs.mostRecentRequest,
35708           GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
35709 
35710 
35711 
35712       // ######################################################
35713       // Try group assignment on assignment by wsAssignAssignOwnerAttributeDefNameLookups
35714 
35715       baos = new ByteArrayOutputStream();
35716       System.setOut(new PrintStream(baos));
35717 
35718       GrouperClient.main(GrouperClientUtils.splitTrim(
35719           "--operation=getAttributeAssignmentsWs --attributeAssignType=any_mem_asgn --ownerMembershipAny0SubjectId=" + member.getSubjectId()
35720           + " --ownerMembershipAny0GroupName=" + group1.getName()
35721           ,
35722         " "));
35723 
35724       System.out.flush();
35725       output = new String(baos.toByteArray());
35726 
35727       System.setOut(systemOut);
35728 
35729       outputLines = GrouperClientUtils.splitTrim(output, "\n");
35730 
35731       // match: Index: 0: attributeAssignType: group_asgn, owner: 91dba6fbe4e9483c876f3af32039ed19, attributeDefNameName: test:testAttributeAssignAssignName, action: assign, values: 123, enabled: T, id: b0cccccf4af14af9be9c5df294f875e1
35732       // match: ^Index: (\d+)\: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F)$
35733       pattern = Pattern
35734           .compile("^Index: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName: (.+), action\\: (.+), values: (.+), enabled\\: (T|F), id: (.+)$");
35735 
35736       assertEquals(1, GrouperUtil.length(outputLines));
35737 
35738       outputLine = outputLines[0];
35739 
35740       matcher = pattern.matcher(outputLine);
35741 
35742       assertTrue(outputLine, matcher.matches());
35743       assertEquals(outputLine, "0", matcher.group(1));
35744       assertEquals(outputLine, "any_mem_asgn", matcher.group(2));
35745       assertEquals(outputLine, attributeAssign.getId(), matcher.group(3));
35746       assertEquals(outputLine, "test:testAttributeAssignAssignName", matcher.group(4));
35747       assertEquals(outputLine, "assign", matcher.group(5));
35748       assertEquals(outputLine, "123", matcher.group(6));
35749       assertEquals(outputLine, "T", matcher.group(7));
35750       assertEquals(outputLine, attributeAssign2.getId(), matcher.group(8));
35751 
35752       assertTrue(GrouperClientWs.mostRecentRequest,
35753           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
35754       assertTrue(GrouperClientWs.mostRecentRequest,
35755           !GrouperClientWs.mostRecentRequest.contains("<actions>"));
35756       assertTrue(GrouperClientWs.mostRecentRequest,
35757           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
35758       assertTrue(GrouperClientWs.mostRecentRequest,
35759           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
35760       assertTrue(GrouperClientWs.mostRecentRequest,
35761           !GrouperClientWs.mostRecentRequest.contains("enabled"));
35762       assertTrue(GrouperClientWs.mostRecentRequest,
35763           !GrouperClientWs.mostRecentRequest.contains("includeAssignmentsOnAssignments"));
35764       assertTrue(GrouperClientWs.mostRecentRequest,
35765           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
35766       assertTrue(GrouperClientWs.mostRecentRequest,
35767           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
35768       assertTrue(GrouperClientWs.mostRecentRequest,
35769           !GrouperClientWs.mostRecentRequest.contains("params"));
35770       assertTrue(GrouperClientWs.mostRecentRequest,
35771           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
35772       assertTrue(GrouperClientWs.mostRecentRequest,
35773           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookups"));
35774       assertFalse(GrouperClientWs.mostRecentRequest,
35775           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
35776       assertFalse(GrouperClientWs.mostRecentRequest,
35777           GrouperClientWs.mostRecentRequest.contains("<uuid>"));
35778       assertTrue(GrouperClientWs.mostRecentRequest,
35779           !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookups"));
35780       assertTrue(GrouperClientWs.mostRecentRequest,
35781           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookups"));
35782       assertTrue(GrouperClientWs.mostRecentRequest,
35783           !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookups"));
35784       assertTrue(GrouperClientWs.mostRecentRequest,
35785           GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookups"));
35786       assertTrue(GrouperClientWs.mostRecentRequest,
35787           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookups"));
35788       assertTrue(GrouperClientWs.mostRecentRequest,
35789           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookups"));
35790       assertTrue(GrouperClientWs.mostRecentRequest,
35791           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookups"));
35792       assertFalse(GrouperClientWs.mostRecentRequest,
35793           GrouperClientWs.mostRecentRequest.contains("attributeDefValueType"));
35794       assertFalse(GrouperClientWs.mostRecentRequest,
35795           GrouperClientWs.mostRecentRequest.contains("theValue"));
35796       assertFalse(GrouperClientWs.mostRecentRequest,
35797           GrouperClientWs.mostRecentRequest.contains(">123<"));
35798       assertFalse(GrouperClientWs.mostRecentRequest,
35799           GrouperClientWs.mostRecentRequest.contains("includeAssignmentsFromAssignments"));
35800       assertFalse(GrouperClientWs.mostRecentRequest,
35801           GrouperClientWs.mostRecentRequest.contains("attributeDefType"));
35802       assertTrue(GrouperClientWs.mostRecentRequest,
35803           !GrouperClientWs.mostRecentRequest.contains("assignAssignOwnerAttributeAssignUuids"));
35804       assertTrue(GrouperClientWs.mostRecentRequest,
35805           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefLookups"));
35806       assertTrue(GrouperClientWs.mostRecentRequest,
35807           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerAttributeDefNameLookups"));
35808       assertTrue(GrouperClientWs.mostRecentRequest,
35809           !GrouperClientWs.mostRecentRequest.contains("wsAssignAssignOwnerActions"));
35810 
35811 
35812     } finally {
35813       System.setOut(systemOut);
35814     }
35815 
35816   }
35817 
35818   /**
35819    * @throws Exception
35820    */
35821   public void testAssignAttributesBatchGroup() throws Exception {
35822 
35823     AttributeDefName attributeDefName = AttributeDefNameTest.exampleAttributeDefNameDb("test", "testAttributeAssignDefName");
35824 
35825     final AttributeDef attributeDef = attributeDefName.getAttributeDef();
35826 
35827     attributeDef.setValueType(AttributeDefValueType.integer);
35828     attributeDef.setMultiValued(true);
35829     attributeDef.store();
35830 
35831     Group group = new GroupSave(GrouperSession.staticGrouperSession()).assignSaveMode(SaveMode.INSERT_OR_UPDATE)
35832       .assignGroupNameToEdit("test:groupTestAttrAssign").assignName("test:groupTestAttrAssign").assignCreateParentStemsIfNotExist(true)
35833       .assignDescription("description").save();
35834 
35835     //test subject 0 can view and read
35836     group.grantPriv(SubjectTestHelper.SUBJ0, AccessPrivilege.VIEW);
35837     attributeDef.getPrivilegeDelegate().grantPriv(SubjectTestHelper.SUBJ0, AttributeDefPrivilege.ATTR_READ, false);
35838 
35839     AttributeAssign attributeAssign = null;
35840     //    AttributeAssignResult attributeAssignResult = group.getAttributeDelegate().assignAttribute(attributeDefName);
35841     //     = attributeAssignResult.getAttributeAssign();
35842 
35843     PrintStream systemOut = System.out;
35844 
35845     ByteArrayOutputStream baos = new ByteArrayOutputStream();
35846     System.setOut(new PrintStream(baos));
35847 
35848     try {
35849 
35850       GrouperClient.main(GrouperClientUtils.splitTrim(
35851           "--operation=assignAttributesBatchWs --entry_0_attributeAssignType=group --entry_0_attributeAssignOperation=assign_attr " +
35852           "--entry_0_nameOfAttributeDefName=test:testAttributeAssignDefName --entry_0_ownerGroupName=test:groupTestAttrAssign",
35853           " "));
35854 
35855       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
35856 
35857       System.out.flush();
35858       String output = new String(baos.toByteArray());
35859 
35860       System.setOut(systemOut);
35861 
35862       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
35863 
35864       // match: Index: ${assignIndex}, itemIndex: ${assignItemIndex}: attributeAssignType: group, owner: test:groupTestAttrAssign, attributeDefNameNameName test:testAttributeAssignDefName, action: assign, values: 15,5,5, enable: T, id: a9c83eeb78c04ae5befcea36272d318c, changed: true, valuesChanged: false
35865       // match: ^Index: (\d+), \: group\: (.+), subject\: (.+), list: (.+), type\: (.+), enabled\: (T|F), changed\: (T|F), valuesChanged\: (T|F)$
35866       Pattern pattern = Pattern
35867         .compile("^Index\\: (\\d+), itemIndex: (\\d+)\\: attributeAssignType\\: (.+), owner\\: (.+), attributeDefNameName\\: (.+), action\\: (.+), " +
35868             "values\\: (.+), enabled\\: (T|F), id\\: (.+), changed\\: (T|F), deleted\\: (T|F), valuesChanged\\: (T|F)$");
35869       String outputLine = outputLines[0];
35870 
35871       Matcher matcher = pattern.matcher(outputLines[0]);
35872 
35873       assertTrue(outputLine, matcher.matches());
35874       assertEquals(outputLine, "0", matcher.group(1));
35875       assertEquals(outputLine, "0", matcher.group(2));
35876       assertEquals(outputLine, "group", matcher.group(3));
35877       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(4));
35878       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(5));
35879       assertEquals(outputLine, "assign", matcher.group(6));
35880       assertEquals(outputLine, "none", matcher.group(7));
35881       assertEquals(outputLine, "T", matcher.group(8));
35882       assertEquals(outputLine, attributeAssign.getId(), matcher.group(9));
35883       assertEquals(outputLine, "T", matcher.group(10));
35884       assertEquals(outputLine, "F", matcher.group(11));
35885       assertEquals(outputLine, "F", matcher.group(12));
35886 
35887       assertTrue(GrouperClientWs.mostRecentRequest,
35888           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
35889       assertTrue(GrouperClientWs.mostRecentRequest,
35890           !GrouperClientWs.mostRecentRequest.contains("action"));
35891       assertTrue(GrouperClientWs.mostRecentRequest,
35892           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
35893       assertTrue(GrouperClientWs.mostRecentRequest,
35894           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
35895       assertTrue(GrouperClientWs.mostRecentRequest,
35896           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
35897       assertTrue(GrouperClientWs.mostRecentRequest,
35898           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
35899       assertTrue(GrouperClientWs.mostRecentRequest,
35900           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
35901       assertTrue(GrouperClientWs.mostRecentRequest,
35902           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
35903       assertTrue(GrouperClientWs.mostRecentRequest,
35904           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
35905       assertTrue(GrouperClientWs.mostRecentRequest,
35906           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
35907       assertTrue(GrouperClientWs.mostRecentRequest,
35908           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
35909       assertTrue(GrouperClientWs.mostRecentRequest,
35910           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
35911       assertTrue(GrouperClientWs.mostRecentRequest,
35912           !GrouperClientWs.mostRecentRequest.contains("params"));
35913       assertTrue(GrouperClientWs.mostRecentRequest,
35914           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
35915       assertTrue(GrouperClientWs.mostRecentRequest,
35916           !GrouperClientWs.mostRecentRequest.contains("values"));
35917       assertTrue(GrouperClientWs.mostRecentRequest,
35918           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookup"));
35919       assertTrue(GrouperClientWs.mostRecentRequest,
35920           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookup")
35921           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
35922       assertTrue(GrouperClientWs.mostRecentRequest,
35923           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookup"));
35924       assertTrue(GrouperClientWs.mostRecentRequest,
35925           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookup"));
35926       assertTrue(GrouperClientWs.mostRecentRequest,
35927           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookup")
35928           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
35929       assertTrue(GrouperClientWs.mostRecentRequest,
35930           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookup"));
35931       assertTrue(GrouperClientWs.mostRecentRequest,
35932           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookup"));
35933       assertTrue(GrouperClientWs.mostRecentRequest,
35934           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookup"));
35935       assertTrue(GrouperClientWs.mostRecentRequest,
35936           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookup"));
35937 
35938 
35939       // ######################################################
35940       // Try attributeDefNameId
35941 
35942       baos = new ByteArrayOutputStream();
35943       System.setOut(new PrintStream(baos));
35944 
35945       GrouperClient.main(GrouperClientUtils.splitTrim(
35946           "--operation=assignAttributesBatchWs --entry_0_attributeAssignType=group --entry_0_attributeAssignOperation=assign_attr " +
35947           "--entry_0_uuidOfAttributeDefName=" + attributeDefName.getId() +  " --entry_0_ownerGroupName=test:groupTestAttrAssign",
35948           " "));
35949 
35950       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
35951 
35952       System.out.flush();
35953       output = new String(baos.toByteArray());
35954 
35955       System.setOut(systemOut);
35956 
35957       outputLines = GrouperClientUtils.splitTrim(output, "\n");
35958 
35959       outputLine = outputLines[0];
35960 
35961       matcher = pattern.matcher(outputLines[0]);
35962 
35963       assertTrue(outputLine, matcher.matches());
35964       assertEquals(outputLine, "0", matcher.group(1));
35965       assertEquals(outputLine, "0", matcher.group(2));
35966       assertEquals(outputLine, "group", matcher.group(3));
35967       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(4));
35968       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(5));
35969       assertEquals(outputLine, "assign", matcher.group(6));
35970       assertEquals(outputLine, "none", matcher.group(7));
35971       assertEquals(outputLine, "T", matcher.group(8));
35972       assertEquals(outputLine, attributeAssign.getId(), matcher.group(9));
35973       assertEquals(outputLine, "F", matcher.group(10));
35974       assertEquals(outputLine, "F", matcher.group(11));
35975 
35976       assertTrue(GrouperClientWs.mostRecentRequest,
35977           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
35978       assertTrue(GrouperClientWs.mostRecentRequest,
35979           !GrouperClientWs.mostRecentRequest.contains("action"));
35980       assertTrue(GrouperClientWs.mostRecentRequest,
35981           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
35982       assertTrue(GrouperClientWs.mostRecentRequest,
35983           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
35984       assertTrue(GrouperClientWs.mostRecentRequest,
35985           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
35986       assertTrue(GrouperClientWs.mostRecentRequest,
35987           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
35988       assertTrue(GrouperClientWs.mostRecentRequest,
35989           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
35990       assertTrue(GrouperClientWs.mostRecentRequest,
35991           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
35992       assertTrue(GrouperClientWs.mostRecentRequest,
35993           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
35994       assertTrue(GrouperClientWs.mostRecentRequest,
35995           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
35996       assertTrue(GrouperClientWs.mostRecentRequest,
35997           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
35998       assertTrue(GrouperClientWs.mostRecentRequest,
35999           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
36000       assertTrue(GrouperClientWs.mostRecentRequest,
36001           !GrouperClientWs.mostRecentRequest.contains("params"));
36002       assertTrue(GrouperClientWs.mostRecentRequest,
36003           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
36004       assertTrue(GrouperClientWs.mostRecentRequest,
36005           !GrouperClientWs.mostRecentRequest.contains("values"));
36006       assertTrue(GrouperClientWs.mostRecentRequest,
36007           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookup"));
36008       assertTrue(GrouperClientWs.mostRecentRequest,
36009           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookup")
36010           && GrouperClientWs.mostRecentRequest.contains(attributeDefName.getId()));
36011       assertTrue(GrouperClientWs.mostRecentRequest,
36012           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookup"));
36013       assertTrue(GrouperClientWs.mostRecentRequest,
36014           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookup"));
36015       assertTrue(GrouperClientWs.mostRecentRequest,
36016           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookup")
36017           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
36018       assertTrue(GrouperClientWs.mostRecentRequest,
36019           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookup"));
36020       assertTrue(GrouperClientWs.mostRecentRequest,
36021           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookup"));
36022       assertTrue(GrouperClientWs.mostRecentRequest,
36023           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookup"));
36024       assertTrue(GrouperClientWs.mostRecentRequest,
36025           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookup"));
36026 
36027       // ######################################################
36028       // Try attributeDefNameIdIndex
36029 
36030       baos = new ByteArrayOutputStream();
36031       System.setOut(new PrintStream(baos));
36032 
36033       GrouperClient.main(GrouperClientUtils.splitTrim(
36034           "--operation=assignAttributesBatchWs --entry_0_attributeAssignType=group --entry_0_attributeAssignOperation=assign_attr " +
36035           "--entry_0_idIndexOfAttributeDefName=" + attributeDefName.getIdIndex() +  " --entry_0_ownerGroupName=test:groupTestAttrAssign",
36036           " "));
36037 
36038       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
36039 
36040       System.out.flush();
36041       output = new String(baos.toByteArray());
36042 
36043       System.setOut(systemOut);
36044 
36045       outputLines = GrouperClientUtils.splitTrim(output, "\n");
36046 
36047       outputLine = outputLines[0];
36048 
36049       matcher = pattern.matcher(outputLines[0]);
36050 
36051       assertTrue(outputLine, matcher.matches());
36052       assertEquals(outputLine, "0", matcher.group(1));
36053       assertEquals(outputLine, "0", matcher.group(2));
36054       assertEquals(outputLine, "group", matcher.group(3));
36055       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(4));
36056       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(5));
36057       assertEquals(outputLine, "assign", matcher.group(6));
36058       assertEquals(outputLine, "none", matcher.group(7));
36059       assertEquals(outputLine, "T", matcher.group(8));
36060       assertEquals(outputLine, attributeAssign.getId(), matcher.group(9));
36061       assertEquals(outputLine, "F", matcher.group(10));
36062       assertEquals(outputLine, "F", matcher.group(11));
36063 
36064       assertTrue(GrouperClientWs.mostRecentRequest,
36065           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
36066       assertTrue(GrouperClientWs.mostRecentRequest,
36067           !GrouperClientWs.mostRecentRequest.contains("action"));
36068       assertTrue(GrouperClientWs.mostRecentRequest,
36069           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
36070       assertTrue(GrouperClientWs.mostRecentRequest,
36071           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
36072       assertTrue(GrouperClientWs.mostRecentRequest,
36073           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
36074       assertTrue(GrouperClientWs.mostRecentRequest,
36075           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
36076       assertTrue(GrouperClientWs.mostRecentRequest,
36077           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
36078       assertTrue(GrouperClientWs.mostRecentRequest,
36079           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
36080       assertTrue(GrouperClientWs.mostRecentRequest,
36081           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
36082       assertTrue(GrouperClientWs.mostRecentRequest,
36083           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
36084       assertTrue(GrouperClientWs.mostRecentRequest,
36085           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
36086       assertTrue(GrouperClientWs.mostRecentRequest,
36087           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
36088       assertTrue(GrouperClientWs.mostRecentRequest,
36089           !GrouperClientWs.mostRecentRequest.contains("params"));
36090       assertTrue(GrouperClientWs.mostRecentRequest,
36091           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
36092       assertTrue(GrouperClientWs.mostRecentRequest,
36093           !GrouperClientWs.mostRecentRequest.contains("values"));
36094       assertTrue(GrouperClientWs.mostRecentRequest,
36095           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookup"));
36096       assertTrue(GrouperClientWs.mostRecentRequest,
36097           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookup")
36098           && GrouperClientWs.mostRecentRequest.contains(attributeDefName.getIdIndex().toString()));
36099       assertTrue(GrouperClientWs.mostRecentRequest,
36100           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookup"));
36101       assertTrue(GrouperClientWs.mostRecentRequest,
36102           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookup"));
36103       assertTrue(GrouperClientWs.mostRecentRequest,
36104           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookup")
36105           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
36106       assertTrue(GrouperClientWs.mostRecentRequest,
36107           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookup"));
36108       assertTrue(GrouperClientWs.mostRecentRequest,
36109           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookup"));
36110       assertTrue(GrouperClientWs.mostRecentRequest,
36111           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookup"));
36112       assertTrue(GrouperClientWs.mostRecentRequest,
36113           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookup"));
36114 
36115       // ######################################################
36116       // Try ownerGroupUuid
36117 
36118       baos = new ByteArrayOutputStream();
36119       System.setOut(new PrintStream(baos));
36120 
36121       GrouperClient.main(GrouperClientUtils.splitTrim(
36122           "--operation=assignAttributesBatchWs --entry_0_attributeAssignType=group --entry_0_attributeAssignOperation=assign_attr " +
36123           "--entry_0_nameOfAttributeDefName=test:testAttributeAssignDefName --entry_0_ownerGroupUuid=" + group.getUuid(),
36124           " "));
36125 
36126       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
36127 
36128       System.out.flush();
36129       output = new String(baos.toByteArray());
36130 
36131       System.setOut(systemOut);
36132 
36133       outputLines = GrouperClientUtils.splitTrim(output, "\n");
36134 
36135       outputLine = outputLines[0];
36136 
36137       matcher = pattern.matcher(outputLines[0]);
36138 
36139       assertTrue(outputLine, matcher.matches());
36140       assertEquals(outputLine, "0", matcher.group(1));
36141       assertEquals(outputLine, "0", matcher.group(2));
36142       assertEquals(outputLine, "group", matcher.group(3));
36143       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(4));
36144       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(5));
36145       assertEquals(outputLine, "assign", matcher.group(6));
36146       assertEquals(outputLine, "none", matcher.group(7));
36147       assertEquals(outputLine, "T", matcher.group(8));
36148       assertEquals(outputLine, attributeAssign.getId(), matcher.group(9));
36149       assertEquals(outputLine, "F", matcher.group(10));
36150       assertEquals(outputLine, "F", matcher.group(11));
36151       assertEquals(outputLine, "F", matcher.group(12));
36152 
36153       assertTrue(GrouperClientWs.mostRecentRequest,
36154           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
36155       assertTrue(GrouperClientWs.mostRecentRequest,
36156           !GrouperClientWs.mostRecentRequest.contains("action"));
36157       assertTrue(GrouperClientWs.mostRecentRequest,
36158           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
36159       assertTrue(GrouperClientWs.mostRecentRequest,
36160           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
36161       assertTrue(GrouperClientWs.mostRecentRequest,
36162           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
36163       assertTrue(GrouperClientWs.mostRecentRequest,
36164           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
36165       assertTrue(GrouperClientWs.mostRecentRequest,
36166           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
36167       assertTrue(GrouperClientWs.mostRecentRequest,
36168           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
36169       assertTrue(GrouperClientWs.mostRecentRequest,
36170           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
36171       assertTrue(GrouperClientWs.mostRecentRequest,
36172           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
36173       assertTrue(GrouperClientWs.mostRecentRequest,
36174           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
36175       assertTrue(GrouperClientWs.mostRecentRequest,
36176           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
36177       assertTrue(GrouperClientWs.mostRecentRequest,
36178           !GrouperClientWs.mostRecentRequest.contains("params"));
36179       assertTrue(GrouperClientWs.mostRecentRequest,
36180           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
36181       assertTrue(GrouperClientWs.mostRecentRequest,
36182           !GrouperClientWs.mostRecentRequest.contains("values"));
36183       assertTrue(GrouperClientWs.mostRecentRequest,
36184           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookup"));
36185       assertTrue(GrouperClientWs.mostRecentRequest,
36186           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookup")
36187           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
36188       assertTrue(GrouperClientWs.mostRecentRequest,
36189           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookup"));
36190       assertTrue(GrouperClientWs.mostRecentRequest,
36191           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookup"));
36192       assertTrue(GrouperClientWs.mostRecentRequest,
36193           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookup")
36194           && GrouperClientWs.mostRecentRequest.contains(group.getUuid()));
36195       assertTrue(GrouperClientWs.mostRecentRequest,
36196           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookup"));
36197       assertTrue(GrouperClientWs.mostRecentRequest,
36198           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookup"));
36199       assertTrue(GrouperClientWs.mostRecentRequest,
36200           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookup"));
36201       assertTrue(GrouperClientWs.mostRecentRequest,
36202           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookup"));
36203 
36204       // ######################################################
36205       // Try ownerGroupIdIndex
36206 
36207       baos = new ByteArrayOutputStream();
36208       System.setOut(new PrintStream(baos));
36209 
36210       GrouperClient.main(GrouperClientUtils.splitTrim(
36211           "--operation=assignAttributesBatchWs --entry_0_attributeAssignType=group --entry_0_attributeAssignOperation=assign_attr " +
36212           "--entry_0_nameOfAttributeDefName=test:testAttributeAssignDefName --entry_0_ownerGroupIdIndex=" + group.getIdIndex(),
36213           " "));
36214 
36215       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
36216 
36217       System.out.flush();
36218       output = new String(baos.toByteArray());
36219 
36220       System.setOut(systemOut);
36221 
36222       outputLines = GrouperClientUtils.splitTrim(output, "\n");
36223 
36224       outputLine = outputLines[0];
36225 
36226       matcher = pattern.matcher(outputLines[0]);
36227 
36228       assertTrue(outputLine, matcher.matches());
36229       assertEquals(outputLine, "0", matcher.group(1));
36230       assertEquals(outputLine, "0", matcher.group(2));
36231       assertEquals(outputLine, "group", matcher.group(3));
36232       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(4));
36233       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(5));
36234       assertEquals(outputLine, "assign", matcher.group(6));
36235       assertEquals(outputLine, "none", matcher.group(7));
36236       assertEquals(outputLine, "T", matcher.group(8));
36237       assertEquals(outputLine, attributeAssign.getId(), matcher.group(9));
36238       assertEquals(outputLine, "F", matcher.group(10));
36239       assertEquals(outputLine, "F", matcher.group(11));
36240       assertEquals(outputLine, "F", matcher.group(12));
36241 
36242       assertTrue(GrouperClientWs.mostRecentRequest,
36243           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
36244       assertTrue(GrouperClientWs.mostRecentRequest,
36245           !GrouperClientWs.mostRecentRequest.contains("action"));
36246       assertTrue(GrouperClientWs.mostRecentRequest,
36247           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
36248       assertTrue(GrouperClientWs.mostRecentRequest,
36249           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
36250       assertTrue(GrouperClientWs.mostRecentRequest,
36251           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
36252       assertTrue(GrouperClientWs.mostRecentRequest,
36253           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
36254       assertTrue(GrouperClientWs.mostRecentRequest,
36255           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
36256       assertTrue(GrouperClientWs.mostRecentRequest,
36257           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
36258       assertTrue(GrouperClientWs.mostRecentRequest,
36259           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
36260       assertTrue(GrouperClientWs.mostRecentRequest,
36261           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
36262       assertTrue(GrouperClientWs.mostRecentRequest,
36263           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
36264       assertTrue(GrouperClientWs.mostRecentRequest,
36265           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
36266       assertTrue(GrouperClientWs.mostRecentRequest,
36267           !GrouperClientWs.mostRecentRequest.contains("params"));
36268       assertTrue(GrouperClientWs.mostRecentRequest,
36269           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
36270       assertTrue(GrouperClientWs.mostRecentRequest,
36271           !GrouperClientWs.mostRecentRequest.contains("values"));
36272       assertTrue(GrouperClientWs.mostRecentRequest,
36273           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookup"));
36274       assertTrue(GrouperClientWs.mostRecentRequest,
36275           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookup")
36276           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
36277       assertTrue(GrouperClientWs.mostRecentRequest,
36278           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookup"));
36279       assertTrue(GrouperClientWs.mostRecentRequest,
36280           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookup"));
36281       assertTrue(GrouperClientWs.mostRecentRequest,
36282           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookup")
36283           && GrouperClientWs.mostRecentRequest.contains(group.getIdIndex().toString()));
36284       assertTrue(GrouperClientWs.mostRecentRequest,
36285           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookup"));
36286       assertTrue(GrouperClientWs.mostRecentRequest,
36287           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookup"));
36288       assertTrue(GrouperClientWs.mostRecentRequest,
36289           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookup"));
36290       assertTrue(GrouperClientWs.mostRecentRequest,
36291           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookup"));
36292 
36293       // ######################################################
36294       // Try enabledTime
36295 
36296       baos = new ByteArrayOutputStream();
36297       System.setOut(new PrintStream(baos));
36298 
36299       GrouperClient.main(GrouperClientUtils.splitTrim(
36300           "--operation=assignAttributesBatchWs --entry_0_attributeAssignType=group --entry_0_attributeAssignOperation=assign_attr " +
36301           "--entry_0_nameOfAttributeDefName=test:testAttributeAssignDefName --entry_0_ownerGroupName=test:groupTestAttrAssign "
36302           + " --entry_0_assignmentEnabledTime=2010/03/05_17:05:13.123",
36303           " "));
36304 
36305       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
36306 
36307       System.out.flush();
36308       output = new String(baos.toByteArray());
36309 
36310       System.setOut(systemOut);
36311 
36312       outputLines = GrouperClientUtils.splitTrim(output, "\n");
36313 
36314       outputLine = outputLines[0];
36315 
36316       matcher = pattern.matcher(outputLines[0]);
36317 
36318       assertTrue(outputLine, matcher.matches());
36319       assertEquals(outputLine, "0", matcher.group(1));
36320       assertEquals(outputLine, "0", matcher.group(2));
36321       assertEquals(outputLine, "group", matcher.group(3));
36322       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(4));
36323       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(5));
36324       assertEquals(outputLine, "assign", matcher.group(6));
36325       assertEquals(outputLine, "none", matcher.group(7));
36326       assertEquals(outputLine, "T", matcher.group(8));
36327       assertEquals(outputLine, attributeAssign.getId(), matcher.group(9));
36328       assertEquals(outputLine, "T", matcher.group(10));
36329       assertEquals(outputLine, "F", matcher.group(11));
36330 
36331       assertTrue(GrouperClientWs.mostRecentRequest,
36332           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
36333       assertTrue(GrouperClientWs.mostRecentRequest,
36334           !GrouperClientWs.mostRecentRequest.contains("action"));
36335       assertTrue(GrouperClientWs.mostRecentRequest,
36336           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
36337       assertTrue(GrouperClientWs.mostRecentRequest,
36338           GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime")
36339           && GrouperClientWs.mostRecentRequest.contains("2010/03/05 17:05:13.123"));
36340       assertTrue(GrouperClientWs.mostRecentResponse,
36341           GrouperClientWs.mostRecentResponse.contains("2010/03/05 17:05:13.123"));
36342       assertTrue(GrouperClientWs.mostRecentRequest,
36343           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
36344       assertTrue(GrouperClientWs.mostRecentRequest,
36345           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
36346       assertTrue(GrouperClientWs.mostRecentRequest,
36347           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
36348       assertTrue(GrouperClientWs.mostRecentRequest,
36349           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
36350       assertTrue(GrouperClientWs.mostRecentRequest,
36351           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
36352       assertTrue(GrouperClientWs.mostRecentRequest,
36353           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
36354       assertTrue(GrouperClientWs.mostRecentRequest,
36355           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
36356       assertTrue(GrouperClientWs.mostRecentRequest,
36357           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
36358       assertTrue(GrouperClientWs.mostRecentRequest,
36359           !GrouperClientWs.mostRecentRequest.contains("params"));
36360       assertTrue(GrouperClientWs.mostRecentRequest,
36361           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
36362       assertTrue(GrouperClientWs.mostRecentRequest,
36363           !GrouperClientWs.mostRecentRequest.contains("values"));
36364       assertTrue(GrouperClientWs.mostRecentRequest,
36365           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookup"));
36366       assertTrue(GrouperClientWs.mostRecentRequest,
36367           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookup")
36368           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
36369       assertTrue(GrouperClientWs.mostRecentRequest,
36370           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookup"));
36371       assertTrue(GrouperClientWs.mostRecentRequest,
36372           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookup"));
36373       assertTrue(GrouperClientWs.mostRecentRequest,
36374           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookup")
36375           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
36376       assertTrue(GrouperClientWs.mostRecentRequest,
36377           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookup"));
36378       assertTrue(GrouperClientWs.mostRecentRequest,
36379           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookup"));
36380       assertTrue(GrouperClientWs.mostRecentRequest,
36381           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookup"));
36382       assertTrue(GrouperClientWs.mostRecentRequest,
36383           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookup"));
36384 
36385       // ######################################################
36386       // Try disabledTime
36387 
36388       baos = new ByteArrayOutputStream();
36389       System.setOut(new PrintStream(baos));
36390 
36391       GrouperClient.main(GrouperClientUtils.splitTrim(
36392           "--operation=assignAttributesBatchWs --entry_0_attributeAssignType=group --entry_0_attributeAssignOperation=assign_attr " +
36393           "--entry_0_nameOfAttributeDefName=test:testAttributeAssignDefName --entry_0_ownerGroupName=test:groupTestAttrAssign "
36394           + " --entry_0_assignmentDisabledTime=2010/03/05_17:05:13.123",
36395           " "));
36396 
36397       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
36398 
36399       System.out.flush();
36400       output = new String(baos.toByteArray());
36401 
36402       System.setOut(systemOut);
36403 
36404       outputLines = GrouperClientUtils.splitTrim(output, "\n");
36405 
36406       outputLine = outputLines[0];
36407 
36408       matcher = pattern.matcher(outputLines[0]);
36409 
36410       assertTrue(outputLine, matcher.matches());
36411       assertEquals(outputLine, "0", matcher.group(1));
36412       assertEquals(outputLine, "0", matcher.group(2));
36413       assertEquals(outputLine, "group", matcher.group(3));
36414       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(4));
36415       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(5));
36416       assertEquals(outputLine, "assign", matcher.group(6));
36417       assertEquals(outputLine, "none", matcher.group(7));
36418       assertEquals(outputLine, "F", matcher.group(8));
36419       assertEquals(outputLine, attributeAssign.getId(), matcher.group(9));
36420       assertEquals(outputLine, "T", matcher.group(10));
36421       assertEquals(outputLine, "F", matcher.group(11));
36422 
36423       assertTrue(GrouperClientWs.mostRecentRequest,
36424           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
36425       assertTrue(GrouperClientWs.mostRecentRequest,
36426           !GrouperClientWs.mostRecentRequest.contains("action"));
36427       assertTrue(GrouperClientWs.mostRecentRequest,
36428           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
36429       assertTrue(GrouperClientWs.mostRecentRequest,
36430           GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime")
36431           && GrouperClientWs.mostRecentRequest.contains("2010/03/05 17:05:13.123"));
36432       assertTrue(GrouperClientWs.mostRecentResponse,
36433           GrouperClientWs.mostRecentResponse.contains("2010/03/05 17:05:13.123"));
36434       assertTrue(GrouperClientWs.mostRecentRequest,
36435           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
36436       assertTrue(GrouperClientWs.mostRecentRequest,
36437           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
36438       assertTrue(GrouperClientWs.mostRecentRequest,
36439           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
36440       assertTrue(GrouperClientWs.mostRecentRequest,
36441           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
36442       assertTrue(GrouperClientWs.mostRecentRequest,
36443           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
36444       assertTrue(GrouperClientWs.mostRecentRequest,
36445           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
36446       assertTrue(GrouperClientWs.mostRecentRequest,
36447           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
36448       assertTrue(GrouperClientWs.mostRecentRequest,
36449           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
36450       assertTrue(GrouperClientWs.mostRecentRequest,
36451           !GrouperClientWs.mostRecentRequest.contains("params"));
36452       assertTrue(GrouperClientWs.mostRecentRequest,
36453           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
36454       assertTrue(GrouperClientWs.mostRecentRequest,
36455           !GrouperClientWs.mostRecentRequest.contains("values"));
36456       assertTrue(GrouperClientWs.mostRecentRequest,
36457           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookup"));
36458       assertTrue(GrouperClientWs.mostRecentRequest,
36459           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookup")
36460           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
36461       assertTrue(GrouperClientWs.mostRecentRequest,
36462           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookup"));
36463       assertTrue(GrouperClientWs.mostRecentRequest,
36464           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookup"));
36465       assertTrue(GrouperClientWs.mostRecentRequest,
36466           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookup")
36467           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
36468       assertTrue(GrouperClientWs.mostRecentRequest,
36469           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookup"));
36470       assertTrue(GrouperClientWs.mostRecentRequest,
36471           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookup"));
36472       assertTrue(GrouperClientWs.mostRecentRequest,
36473           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookup"));
36474       assertTrue(GrouperClientWs.mostRecentRequest,
36475           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookup"));
36476 
36477       // ######################################################
36478       // Try assignmentNotes
36479 
36480       baos = new ByteArrayOutputStream();
36481       System.setOut(new PrintStream(baos));
36482 
36483       GrouperClient.main(GrouperClientUtils.splitTrim(
36484           "--operation=assignAttributesBatchWs --entry_0_attributeAssignType=group --entry_0_attributeAssignOperation=assign_attr " +
36485           "--entry_0_nameOfAttributeDefName=test:testAttributeAssignDefName --entry_0_ownerGroupName=test:groupTestAttrAssign "
36486           + " --entry_0_assignmentNotes=theNotes",
36487           " "));
36488 
36489       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
36490 
36491       System.out.flush();
36492       output = new String(baos.toByteArray());
36493 
36494       System.setOut(systemOut);
36495 
36496       outputLines = GrouperClientUtils.splitTrim(output, "\n");
36497 
36498       outputLine = outputLines[0];
36499 
36500       matcher = pattern.matcher(outputLines[0]);
36501 
36502       assertTrue(outputLine, matcher.matches());
36503       assertEquals(outputLine, "0", matcher.group(1));
36504       assertEquals(outputLine, "0", matcher.group(2));
36505       assertEquals(outputLine, "group", matcher.group(3));
36506       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(4));
36507       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(5));
36508       assertEquals(outputLine, "assign", matcher.group(6));
36509       assertEquals(outputLine, "none", matcher.group(7));
36510       assertEquals(outputLine, "T", matcher.group(8));
36511       assertEquals(outputLine, attributeAssign.getId(), matcher.group(9));
36512       assertEquals(outputLine, "T", matcher.group(10));
36513       assertEquals(outputLine, "F", matcher.group(11));
36514 
36515       assertTrue(GrouperClientWs.mostRecentRequest,
36516           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
36517       assertTrue(GrouperClientWs.mostRecentRequest,
36518           !GrouperClientWs.mostRecentRequest.contains("action"));
36519       assertTrue(GrouperClientWs.mostRecentRequest,
36520           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
36521       assertTrue(GrouperClientWs.mostRecentRequest,
36522           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
36523       assertTrue(GrouperClientWs.mostRecentResponse,
36524           GrouperClientWs.mostRecentResponse.contains("theNotes"));
36525       assertTrue(GrouperClientWs.mostRecentRequest,
36526           GrouperClientWs.mostRecentRequest.contains("assignmentNotes")
36527           && GrouperClientWs.mostRecentRequest.contains("theNotes") );
36528       assertTrue(GrouperClientWs.mostRecentRequest,
36529           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
36530       assertTrue(GrouperClientWs.mostRecentRequest,
36531           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
36532       assertTrue(GrouperClientWs.mostRecentRequest,
36533           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
36534       assertTrue(GrouperClientWs.mostRecentRequest,
36535           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
36536       assertTrue(GrouperClientWs.mostRecentRequest,
36537           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
36538       assertTrue(GrouperClientWs.mostRecentRequest,
36539           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
36540       assertTrue(GrouperClientWs.mostRecentRequest,
36541           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
36542       assertTrue(GrouperClientWs.mostRecentRequest,
36543           !GrouperClientWs.mostRecentRequest.contains("params"));
36544       assertTrue(GrouperClientWs.mostRecentRequest,
36545           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
36546       assertTrue(GrouperClientWs.mostRecentRequest,
36547           !GrouperClientWs.mostRecentRequest.contains("values"));
36548       assertTrue(GrouperClientWs.mostRecentRequest,
36549           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookup"));
36550       assertTrue(GrouperClientWs.mostRecentRequest,
36551           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookup")
36552           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
36553       assertTrue(GrouperClientWs.mostRecentRequest,
36554           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookup"));
36555       assertTrue(GrouperClientWs.mostRecentRequest,
36556           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookup"));
36557       assertTrue(GrouperClientWs.mostRecentRequest,
36558           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookup")
36559           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
36560       assertTrue(GrouperClientWs.mostRecentRequest,
36561           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookup"));
36562       assertTrue(GrouperClientWs.mostRecentRequest,
36563           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookup"));
36564       assertTrue(GrouperClientWs.mostRecentRequest,
36565           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookup"));
36566       assertTrue(GrouperClientWs.mostRecentRequest,
36567           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookup"));
36568 
36569 
36570       // ######################################################
36571       // Try delegatable
36572 
36573       baos = new ByteArrayOutputStream();
36574       System.setOut(new PrintStream(baos));
36575 
36576       GrouperClient.main(GrouperClientUtils.splitTrim(
36577           "--operation=assignAttributesBatchWs --entry_0_attributeAssignType=group --entry_0_attributeAssignOperation=assign_attr " +
36578           "--entry_0_nameOfAttributeDefName=test:testAttributeAssignDefName --entry_0_ownerGroupName=test:groupTestAttrAssign "
36579           + " --entry_0_delegatable=FALSE",
36580           " "));
36581 
36582       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
36583 
36584       System.out.flush();
36585       output = new String(baos.toByteArray());
36586 
36587       System.setOut(systemOut);
36588 
36589       outputLines = GrouperClientUtils.splitTrim(output, "\n");
36590 
36591       outputLine = outputLines[0];
36592 
36593       matcher = pattern.matcher(outputLines[0]);
36594 
36595       assertTrue(outputLine, matcher.matches());
36596       assertEquals(outputLine, "0", matcher.group(1));
36597       assertEquals(outputLine, "0", matcher.group(2));
36598       assertEquals(outputLine, "group", matcher.group(3));
36599       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(4));
36600       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(5));
36601       assertEquals(outputLine, "assign", matcher.group(6));
36602       assertEquals(outputLine, "none", matcher.group(7));
36603       assertEquals(outputLine, "T", matcher.group(8));
36604       assertEquals(outputLine, attributeAssign.getId(), matcher.group(9));
36605       assertEquals(outputLine, "T", matcher.group(10));
36606       assertEquals(outputLine, "F", matcher.group(11));
36607 
36608       assertTrue(GrouperClientWs.mostRecentRequest,
36609           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
36610       assertTrue(GrouperClientWs.mostRecentRequest,
36611           !GrouperClientWs.mostRecentRequest.contains("action"));
36612       assertTrue(GrouperClientWs.mostRecentRequest,
36613           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
36614       assertTrue(GrouperClientWs.mostRecentRequest,
36615           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
36616       //assertTrue(GrouperClientWs.mostRecentResponse,
36617       //    GrouperClientWs.mostRecentResponse.contains("theNotes"));
36618       assertTrue(GrouperClientWs.mostRecentRequest,
36619           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
36620       assertTrue(GrouperClientWs.mostRecentRequest,
36621           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
36622       assertTrue(GrouperClientWs.mostRecentRequest,
36623           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
36624       assertTrue(GrouperClientWs.mostRecentRequest,
36625           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
36626       assertTrue(GrouperClientWs.mostRecentRequest,
36627           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
36628       assertTrue(GrouperClientWs.mostRecentRequest,
36629           GrouperClientWs.mostRecentRequest.contains("delegatable")
36630           && GrouperClientWs.mostRecentRequest.contains("FALSE"));
36631       assertTrue(GrouperClientWs.mostRecentRequest,
36632           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
36633       assertTrue(GrouperClientWs.mostRecentRequest,
36634           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
36635       assertTrue(GrouperClientWs.mostRecentRequest,
36636           !GrouperClientWs.mostRecentRequest.contains("params"));
36637       assertTrue(GrouperClientWs.mostRecentRequest,
36638           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
36639       assertTrue(GrouperClientWs.mostRecentRequest,
36640           !GrouperClientWs.mostRecentRequest.contains("values"));
36641       assertTrue(GrouperClientWs.mostRecentRequest,
36642           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookup"));
36643       assertTrue(GrouperClientWs.mostRecentRequest,
36644           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookup")
36645           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
36646       assertTrue(GrouperClientWs.mostRecentRequest,
36647           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookup"));
36648       assertTrue(GrouperClientWs.mostRecentRequest,
36649           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookup"));
36650       assertTrue(GrouperClientWs.mostRecentRequest,
36651           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookup")
36652           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
36653       assertTrue(GrouperClientWs.mostRecentRequest,
36654           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookup"));
36655       assertTrue(GrouperClientWs.mostRecentRequest,
36656           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookup"));
36657       assertTrue(GrouperClientWs.mostRecentRequest,
36658           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookup"));
36659       assertTrue(GrouperClientWs.mostRecentRequest,
36660           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookup"));
36661 
36662       // ######################################################
36663       // Try action
36664 
36665       baos = new ByteArrayOutputStream();
36666       System.setOut(new PrintStream(baos));
36667 
36668       GrouperClient.main(GrouperClientUtils.splitTrim(
36669           "--operation=assignAttributesBatchWs --entry_0_attributeAssignType=group --entry_0_attributeAssignOperation=assign_attr " +
36670           "--entry_0_nameOfAttributeDefName=test:testAttributeAssignDefName --entry_0_ownerGroupName=test:groupTestAttrAssign "
36671           + " --entry_0_action=assign",
36672           " "));
36673 
36674       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
36675 
36676       System.out.flush();
36677       output = new String(baos.toByteArray());
36678 
36679       System.setOut(systemOut);
36680 
36681       outputLines = GrouperClientUtils.splitTrim(output, "\n");
36682 
36683       outputLine = outputLines[0];
36684 
36685       matcher = pattern.matcher(outputLines[0]);
36686 
36687       assertTrue(outputLine, matcher.matches());
36688       assertEquals(outputLine, "0", matcher.group(1));
36689       assertEquals(outputLine, "0", matcher.group(2));
36690       assertEquals(outputLine, "group", matcher.group(3));
36691       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(4));
36692       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(5));
36693       assertEquals(outputLine, "assign", matcher.group(6));
36694       assertEquals(outputLine, "none", matcher.group(7));
36695       assertEquals(outputLine, "T", matcher.group(8));
36696       assertEquals(outputLine, attributeAssign.getId(), matcher.group(9));
36697       assertEquals(outputLine, "F", matcher.group(10));
36698       assertEquals(outputLine, "F", matcher.group(11));
36699 
36700       assertTrue(GrouperClientWs.mostRecentRequest,
36701           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
36702       assertTrue(GrouperClientWs.mostRecentRequest,
36703           GrouperClientWs.mostRecentRequest.contains("action"));
36704       assertTrue(GrouperClientWs.mostRecentRequest,
36705           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
36706       assertTrue(GrouperClientWs.mostRecentRequest,
36707           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
36708       //assertTrue(GrouperClientWs.mostRecentResponse,
36709       //    GrouperClientWs.mostRecentResponse.contains("theNotes"));
36710       assertTrue(GrouperClientWs.mostRecentRequest,
36711           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
36712       assertTrue(GrouperClientWs.mostRecentRequest,
36713           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
36714       assertTrue(GrouperClientWs.mostRecentRequest,
36715           !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
36716       assertTrue(GrouperClientWs.mostRecentRequest,
36717           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
36718       assertTrue(GrouperClientWs.mostRecentRequest,
36719           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
36720       assertTrue(GrouperClientWs.mostRecentRequest,
36721           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
36722       assertTrue(GrouperClientWs.mostRecentRequest,
36723           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
36724       assertTrue(GrouperClientWs.mostRecentRequest,
36725           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
36726       assertTrue(GrouperClientWs.mostRecentRequest,
36727           !GrouperClientWs.mostRecentRequest.contains("params"));
36728       assertTrue(GrouperClientWs.mostRecentRequest,
36729           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
36730       assertTrue(GrouperClientWs.mostRecentRequest,
36731           !GrouperClientWs.mostRecentRequest.contains("values"));
36732       assertTrue(GrouperClientWs.mostRecentRequest,
36733           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookup"));
36734       assertTrue(GrouperClientWs.mostRecentRequest,
36735           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookup")
36736           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
36737       assertTrue(GrouperClientWs.mostRecentRequest,
36738           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookup"));
36739       assertTrue(GrouperClientWs.mostRecentRequest,
36740           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookup"));
36741       assertTrue(GrouperClientWs.mostRecentRequest,
36742           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookup")
36743           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
36744       assertTrue(GrouperClientWs.mostRecentRequest,
36745           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookup"));
36746       assertTrue(GrouperClientWs.mostRecentRequest,
36747           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookup"));
36748       assertTrue(GrouperClientWs.mostRecentRequest,
36749           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookup"));
36750       assertTrue(GrouperClientWs.mostRecentRequest,
36751           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookup"));
36752 
36753       // ######################################################
36754       // Try values
36755 
36756       baos = new ByteArrayOutputStream();
36757       System.setOut(new PrintStream(baos));
36758 
36759       GrouperClient.main(GrouperClientUtils.splitTrim(
36760           "--operation=assignAttributesBatchWs --entry_0_attributeAssignType=group --entry_0_attributeAssignOperation=assign_attr " +
36761           "--entry_0_nameOfAttributeDefName=test:testAttributeAssignDefName --entry_0_ownerGroupName=test:groupTestAttrAssign "
36762           + " --entry_0_values0System=3 --entry_0_values1System=4 --entry_0_values2System=5 --entry_0_attributeAssignValueOperation=replace_values",
36763           " "));
36764 
36765       attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
36766 
36767       System.out.flush();
36768       output = new String(baos.toByteArray());
36769 
36770       System.setOut(systemOut);
36771 
36772       outputLines = GrouperClientUtils.splitTrim(output, "\n");
36773 
36774       outputLine = outputLines[0];
36775 
36776       matcher = pattern.matcher(outputLines[0]);
36777 
36778       assertTrue(outputLine, matcher.matches());
36779       assertEquals(outputLine, "0", matcher.group(1));
36780       assertEquals(outputLine, "0", matcher.group(2));
36781       assertEquals(outputLine, "group", matcher.group(3));
36782       assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(4));
36783       assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(5));
36784       assertEquals(outputLine, "assign", matcher.group(6));
36785       assertEquals(outputLine, "3,4,5", matcher.group(7));
36786       assertEquals(outputLine, "T", matcher.group(8));
36787       assertEquals(outputLine, attributeAssign.getId(), matcher.group(9));
36788       assertEquals(outputLine, "F", matcher.group(10));
36789       assertEquals(outputLine, "F", matcher.group(11));
36790       assertEquals(outputLine, "T", matcher.group(12));
36791 
36792       assertTrue(GrouperClientWs.mostRecentRequest,
36793           !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
36794       assertTrue(GrouperClientWs.mostRecentRequest,
36795           !GrouperClientWs.mostRecentRequest.contains("action"));
36796       assertTrue(GrouperClientWs.mostRecentRequest,
36797           !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
36798       assertTrue(GrouperClientWs.mostRecentRequest,
36799           !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
36800       //assertTrue(GrouperClientWs.mostRecentResponse,
36801       //    GrouperClientWs.mostRecentResponse.contains("theNotes"));
36802       assertTrue(GrouperClientWs.mostRecentRequest,
36803           !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
36804       assertTrue(GrouperClientWs.mostRecentRequest,
36805           GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
36806       assertTrue(GrouperClientWs.mostRecentRequest,
36807           GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
36808       assertTrue(GrouperClientWs.mostRecentRequest,
36809           GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
36810       assertTrue(GrouperClientWs.mostRecentRequest,
36811           !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
36812       assertTrue(GrouperClientWs.mostRecentRequest,
36813           !GrouperClientWs.mostRecentRequest.contains("delegatable"));
36814       assertTrue(GrouperClientWs.mostRecentRequest,
36815           !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
36816       assertTrue(GrouperClientWs.mostRecentRequest,
36817           !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
36818       assertTrue(GrouperClientWs.mostRecentRequest,
36819           !GrouperClientWs.mostRecentRequest.contains("params"));
36820       assertTrue(GrouperClientWs.mostRecentRequest,
36821           !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
36822       assertTrue(GrouperClientWs.mostRecentRequest,
36823           GrouperClientWs.mostRecentRequest.contains("values")
36824           && GrouperClientWs.mostRecentRequest.contains(">3<")
36825           && GrouperClientWs.mostRecentRequest.contains(">4<")
36826           && GrouperClientWs.mostRecentRequest.contains(">5<"));
36827       assertTrue(GrouperClientWs.mostRecentRequest,
36828           !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookup"));
36829       assertTrue(GrouperClientWs.mostRecentRequest,
36830           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookup")
36831           && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
36832       assertTrue(GrouperClientWs.mostRecentRequest,
36833           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookup"));
36834       assertTrue(GrouperClientWs.mostRecentRequest,
36835           !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookup"));
36836       assertTrue(GrouperClientWs.mostRecentRequest,
36837           GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookup")
36838           && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
36839       assertTrue(GrouperClientWs.mostRecentRequest,
36840           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookup"));
36841       assertTrue(GrouperClientWs.mostRecentRequest,
36842           !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookup"));
36843       assertTrue(GrouperClientWs.mostRecentRequest,
36844           !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookup"));
36845       assertTrue(GrouperClientWs.mostRecentRequest,
36846           !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookup"));
36847 
36848   //    // ######################################################
36849   //    // includeGroupDetail
36850   //
36851   //    baos = new ByteArrayOutputStream();
36852   //    System.setOut(new PrintStream(baos));
36853   //
36854   //    GrouperClient.main(GrouperClientUtils.splitTrim(
36855   //        "--operation=assignAttributesBatchWs --entry_0_attributeAssignType=group --entry_0_attributeAssignOperation=assign_attr " +
36856   //        "--entry_0_nameOfAttributeDefName=test:testAttributeAssignDefName --entry_0_ownerGroupName=test:groupTestAttrAssign "
36857   //        + " --includeGroupDetail=T",
36858   //        " "));
36859   //
36860   //    attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
36861   //
36862   //    System.out.flush();
36863   //    output = new String(baos.toByteArray());
36864   //
36865   //    System.setOut(systemOut);
36866   //
36867   //    outputLines = GrouperClientUtils.splitTrim(output, "\n");
36868   //
36869   //    outputLine = outputLines[0];
36870   //
36871   //    matcher = pattern.matcher(outputLines[0]);
36872   //
36873   //    assertTrue(outputLine, matcher.matches());
36874   //    assertEquals(outputLine, "0", matcher.group(1));
36875   //    assertEquals(outputLine, "0", matcher.group(2));
36876   //    assertEquals(outputLine, "group", matcher.group(3));
36877   //    assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(4));
36878   //    assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(5));
36879   //    assertEquals(outputLine, "assign", matcher.group(6));
36880   //    assertEquals(outputLine, "3,4,5", matcher.group(7));
36881   //    assertEquals(outputLine, "T", matcher.group(8));
36882   //    assertEquals(outputLine, attributeAssign.getId(), matcher.group(9));
36883   //    assertEquals(outputLine, "F", matcher.group(10));
36884   //    assertEquals(outputLine, "F", matcher.group(11));
36885   //    assertEquals(outputLine, "F", matcher.group(12));
36886   //
36887   //    assertTrue(GrouperClientWs.mostRecentRequest,
36888   //        !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
36889   //    assertTrue(GrouperClientWs.mostRecentRequest,
36890   //        !GrouperClientWs.mostRecentRequest.contains("action"));
36891   //    assertTrue(GrouperClientWs.mostRecentRequest,
36892   //        !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
36893   //    assertTrue(GrouperClientWs.mostRecentRequest,
36894   //        !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
36895   //    assertTrue(GrouperClientWs.mostRecentRequest,
36896   //        !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
36897   //    assertTrue(GrouperClientWs.mostRecentRequest,
36898   //        GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
36899   //    assertTrue(GrouperClientWs.mostRecentRequest,
36900   //        !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
36901   //    assertTrue(GrouperClientWs.mostRecentRequest,
36902   //        GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
36903   //    assertTrue(GrouperClientWs.mostRecentRequest,
36904   //        !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
36905   //    assertTrue(GrouperClientWs.mostRecentRequest,
36906   //        !GrouperClientWs.mostRecentRequest.contains("delegatable"));
36907   //    assertTrue(GrouperClientWs.mostRecentRequest,
36908   //        GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
36909   //    assertTrue(GrouperClientWs.mostRecentRequest,
36910   //        !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
36911   //    assertTrue(GrouperClientWs.mostRecentRequest,
36912   //        !GrouperClientWs.mostRecentRequest.contains("params"));
36913   //    assertTrue(GrouperClientWs.mostRecentRequest,
36914   //        !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
36915   //    assertTrue(GrouperClientWs.mostRecentRequest,
36916   //        !GrouperClientWs.mostRecentRequest.contains("values"));
36917   //    assertTrue(GrouperClientWs.mostRecentRequest,
36918   //        !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookup"));
36919   //    assertTrue(GrouperClientWs.mostRecentRequest,
36920   //        GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookup")
36921   //        && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
36922   //    assertTrue(GrouperClientWs.mostRecentRequest,
36923   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookup"));
36924   //    assertTrue(GrouperClientWs.mostRecentRequest,
36925   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookup"));
36926   //    assertTrue(GrouperClientWs.mostRecentRequest,
36927   //        GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookup")
36928   //        && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
36929   //    assertTrue(GrouperClientWs.mostRecentRequest,
36930   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookup"));
36931   //    assertTrue(GrouperClientWs.mostRecentRequest,
36932   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookup"));
36933   //    assertTrue(GrouperClientWs.mostRecentRequest,
36934   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookup"));
36935   //    assertTrue(GrouperClientWs.mostRecentRequest,
36936   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookup"));
36937   //
36938   //
36939   //    // ######################################################
36940   //    // includeSubjectDetail
36941   //
36942   //    baos = new ByteArrayOutputStream();
36943   //    System.setOut(new PrintStream(baos));
36944   //
36945   //    GrouperClient.main(GrouperClientUtils.splitTrim(
36946   //        "--operation=assignAttributesBatchWs --entry_0_attributeAssignType=group --entry_0_attributeAssignOperation=assign_attr " +
36947   //        "--entry_0_nameOfAttributeDefName=test:testAttributeAssignDefName --entry_0_ownerGroupName=test:groupTestAttrAssign "
36948   //        + " --includeSubjectDetail=T",
36949   //        " "));
36950   //
36951   //    attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
36952   //
36953   //    System.out.flush();
36954   //    output = new String(baos.toByteArray());
36955   //
36956   //    System.setOut(systemOut);
36957   //
36958   //    outputLines = GrouperClientUtils.splitTrim(output, "\n");
36959   //
36960   //    outputLine = outputLines[0];
36961   //
36962   //    matcher = pattern.matcher(outputLines[0]);
36963   //
36964   //    assertTrue(outputLine, matcher.matches());
36965   //    assertEquals(outputLine, "0", matcher.group(1));
36966   //    assertEquals(outputLine, "0", matcher.group(2));
36967   //    assertEquals(outputLine, "group", matcher.group(3));
36968   //    assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(4));
36969   //    assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(5));
36970   //    assertEquals(outputLine, "assign", matcher.group(6));
36971   //    assertEquals(outputLine, "3,4,5", matcher.group(7));
36972   //    assertEquals(outputLine, "T", matcher.group(8));
36973   //    assertEquals(outputLine, attributeAssign.getId(), matcher.group(9));
36974   //    assertEquals(outputLine, "F", matcher.group(10));
36975   //    assertEquals(outputLine, "F", matcher.group(11));
36976   //    assertEquals(outputLine, "F", matcher.group(12));
36977   //
36978   //    assertTrue(GrouperClientWs.mostRecentRequest,
36979   //        !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
36980   //    assertTrue(GrouperClientWs.mostRecentRequest,
36981   //        !GrouperClientWs.mostRecentRequest.contains("action"));
36982   //    assertTrue(GrouperClientWs.mostRecentRequest,
36983   //        !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
36984   //    assertTrue(GrouperClientWs.mostRecentRequest,
36985   //        !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
36986   //    assertTrue(GrouperClientWs.mostRecentRequest,
36987   //        !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
36988   //    assertTrue(GrouperClientWs.mostRecentRequest,
36989   //        GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
36990   //    assertTrue(GrouperClientWs.mostRecentRequest,
36991   //        !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
36992   //    assertTrue(GrouperClientWs.mostRecentRequest,
36993   //        GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
36994   //    assertTrue(GrouperClientWs.mostRecentRequest,
36995   //        !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
36996   //    assertTrue(GrouperClientWs.mostRecentRequest,
36997   //        !GrouperClientWs.mostRecentRequest.contains("delegatable"));
36998   //    assertTrue(GrouperClientWs.mostRecentRequest,
36999   //        !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
37000   //    assertTrue(GrouperClientWs.mostRecentRequest,
37001   //        GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
37002   //    assertTrue(GrouperClientWs.mostRecentRequest,
37003   //        !GrouperClientWs.mostRecentRequest.contains("params"));
37004   //    assertTrue(GrouperClientWs.mostRecentRequest,
37005   //        !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
37006   //    assertTrue(GrouperClientWs.mostRecentRequest,
37007   //        !GrouperClientWs.mostRecentRequest.contains("values"));
37008   //    assertTrue(GrouperClientWs.mostRecentRequest,
37009   //        !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookup"));
37010   //    assertTrue(GrouperClientWs.mostRecentRequest,
37011   //        GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookup")
37012   //        && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
37013   //    assertTrue(GrouperClientWs.mostRecentRequest,
37014   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookup"));
37015   //    assertTrue(GrouperClientWs.mostRecentRequest,
37016   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookup"));
37017   //    assertTrue(GrouperClientWs.mostRecentRequest,
37018   //        GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookup")
37019   //        && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
37020   //    assertTrue(GrouperClientWs.mostRecentRequest,
37021   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookup"));
37022   //    assertTrue(GrouperClientWs.mostRecentRequest,
37023   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookup"));
37024   //    assertTrue(GrouperClientWs.mostRecentRequest,
37025   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookup"));
37026   //    assertTrue(GrouperClientWs.mostRecentRequest,
37027   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookup"));
37028   //
37029   //
37030   //    // ######################################################
37031   //    // subjectAttributeNames
37032   //
37033   //    baos = new ByteArrayOutputStream();
37034   //    System.setOut(new PrintStream(baos));
37035   //
37036   //    GrouperClient.main(GrouperClientUtils.splitTrim(
37037   //        "--operation=assignAttributesBatchWs --entry_0_attributeAssignType=group --entry_0_attributeAssignOperation=assign_attr " +
37038   //        "--entry_0_nameOfAttributeDefName=test:testAttributeAssignDefName --entry_0_ownerGroupName=test:groupTestAttrAssign "
37039   //        + " --subjectAttributeNames=abc",
37040   //        " "));
37041   //
37042   //    attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
37043   //
37044   //    System.out.flush();
37045   //    output = new String(baos.toByteArray());
37046   //
37047   //    System.setOut(systemOut);
37048   //
37049   //    outputLines = GrouperClientUtils.splitTrim(output, "\n");
37050   //
37051   //    outputLine = outputLines[0];
37052   //
37053   //    matcher = pattern.matcher(outputLines[0]);
37054   //
37055   //    assertTrue(outputLine, matcher.matches());
37056   //    assertEquals(outputLine, "0", matcher.group(1));
37057   //    assertEquals(outputLine, "0", matcher.group(2));
37058   //    assertEquals(outputLine, "group", matcher.group(3));
37059   //    assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(4));
37060   //    assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(5));
37061   //    assertEquals(outputLine, "assign", matcher.group(6));
37062   //    assertEquals(outputLine, "3,4,5", matcher.group(7));
37063   //    assertEquals(outputLine, "T", matcher.group(8));
37064   //    assertEquals(outputLine, attributeAssign.getId(), matcher.group(9));
37065   //    assertEquals(outputLine, "F", matcher.group(10));
37066   //    assertEquals(outputLine, "F", matcher.group(11));
37067   //    assertEquals(outputLine, "F", matcher.group(12));
37068   //
37069   //    assertTrue(GrouperClientWs.mostRecentRequest,
37070   //        !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
37071   //    assertTrue(GrouperClientWs.mostRecentRequest,
37072   //        !GrouperClientWs.mostRecentRequest.contains("action"));
37073   //    assertTrue(GrouperClientWs.mostRecentRequest,
37074   //        !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
37075   //    assertTrue(GrouperClientWs.mostRecentRequest,
37076   //        !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
37077   //    assertTrue(GrouperClientWs.mostRecentRequest,
37078   //        !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
37079   //    assertTrue(GrouperClientWs.mostRecentRequest,
37080   //        GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
37081   //    assertTrue(GrouperClientWs.mostRecentRequest,
37082   //        !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
37083   //    assertTrue(GrouperClientWs.mostRecentRequest,
37084   //        GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
37085   //    assertTrue(GrouperClientWs.mostRecentRequest,
37086   //        !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
37087   //    assertTrue(GrouperClientWs.mostRecentRequest,
37088   //        !GrouperClientWs.mostRecentRequest.contains("delegatable"));
37089   //    assertTrue(GrouperClientWs.mostRecentRequest,
37090   //        !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
37091   //    assertTrue(GrouperClientWs.mostRecentRequest,
37092   //        !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
37093   //    assertTrue(GrouperClientWs.mostRecentRequest,
37094   //        !GrouperClientWs.mostRecentRequest.contains("params"));
37095   //    assertTrue(GrouperClientWs.mostRecentRequest,
37096   //        GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
37097   //    assertTrue(GrouperClientWs.mostRecentRequest,
37098   //        !GrouperClientWs.mostRecentRequest.contains("values"));
37099   //    assertTrue(GrouperClientWs.mostRecentRequest,
37100   //        !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookup"));
37101   //    assertTrue(GrouperClientWs.mostRecentRequest,
37102   //        GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookup")
37103   //        && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
37104   //    assertTrue(GrouperClientWs.mostRecentRequest,
37105   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookup"));
37106   //    assertTrue(GrouperClientWs.mostRecentRequest,
37107   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookup"));
37108   //    assertTrue(GrouperClientWs.mostRecentRequest,
37109   //        GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookup")
37110   //        && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
37111   //    assertTrue(GrouperClientWs.mostRecentRequest,
37112   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookup"));
37113   //    assertTrue(GrouperClientWs.mostRecentRequest,
37114   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookup"));
37115   //    assertTrue(GrouperClientWs.mostRecentRequest,
37116   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookup"));
37117   //    assertTrue(GrouperClientWs.mostRecentRequest,
37118   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookup"));
37119   //
37120   //
37121   //    // ######################################################
37122   //    // params
37123   //
37124   //    baos = new ByteArrayOutputStream();
37125   //    System.setOut(new PrintStream(baos));
37126   //
37127   //    GrouperClient.main(GrouperClientUtils.splitTrim(
37128   //        "--operation=assignAttributesBatchWs --entry_0_attributeAssignType=group --entry_0_attributeAssignOperation=assign_attr " +
37129   //        "--entry_0_nameOfAttributeDefName=test:testAttributeAssignDefName --entry_0_ownerGroupName=test:groupTestAttrAssign "
37130   //        + " --paramName0=a --paramValue0=b",
37131   //        " "));
37132   //
37133   //    attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
37134   //
37135   //    System.out.flush();
37136   //    output = new String(baos.toByteArray());
37137   //
37138   //    System.setOut(systemOut);
37139   //
37140   //    outputLines = GrouperClientUtils.splitTrim(output, "\n");
37141   //
37142   //    outputLine = outputLines[0];
37143   //
37144   //    matcher = pattern.matcher(outputLines[0]);
37145   //
37146   //    assertTrue(outputLine, matcher.matches());
37147   //    assertEquals(outputLine, "0", matcher.group(1));
37148   //    assertEquals(outputLine, "0", matcher.group(2));
37149   //    assertEquals(outputLine, "group", matcher.group(3));
37150   //    assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(4));
37151   //    assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(5));
37152   //    assertEquals(outputLine, "assign", matcher.group(6));
37153   //    assertEquals(outputLine, "3,4,5", matcher.group(7));
37154   //    assertEquals(outputLine, "T", matcher.group(8));
37155   //    assertEquals(outputLine, attributeAssign.getId(), matcher.group(9));
37156   //    assertEquals(outputLine, "F", matcher.group(10));
37157   //    assertEquals(outputLine, "F", matcher.group(11));
37158   //    assertEquals(outputLine, "F", matcher.group(12));
37159   //
37160   //    assertTrue(GrouperClientWs.mostRecentRequest,
37161   //        !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
37162   //    assertTrue(GrouperClientWs.mostRecentRequest,
37163   //        !GrouperClientWs.mostRecentRequest.contains("action"));
37164   //    assertTrue(GrouperClientWs.mostRecentRequest,
37165   //        !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
37166   //    assertTrue(GrouperClientWs.mostRecentRequest,
37167   //        !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
37168   //    assertTrue(GrouperClientWs.mostRecentRequest,
37169   //        !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
37170   //    assertTrue(GrouperClientWs.mostRecentRequest,
37171   //        GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
37172   //    assertTrue(GrouperClientWs.mostRecentRequest,
37173   //        !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
37174   //    assertTrue(GrouperClientWs.mostRecentRequest,
37175   //        GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
37176   //    assertTrue(GrouperClientWs.mostRecentRequest,
37177   //        !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
37178   //    assertTrue(GrouperClientWs.mostRecentRequest,
37179   //        !GrouperClientWs.mostRecentRequest.contains("delegatable"));
37180   //    assertTrue(GrouperClientWs.mostRecentRequest,
37181   //        !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
37182   //    assertTrue(GrouperClientWs.mostRecentRequest,
37183   //        !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
37184   //    assertTrue(GrouperClientWs.mostRecentRequest,
37185   //        GrouperClientWs.mostRecentRequest.contains("params"));
37186   //    assertTrue(GrouperClientWs.mostRecentRequest,
37187   //        !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
37188   //    assertTrue(GrouperClientWs.mostRecentRequest,
37189   //        !GrouperClientWs.mostRecentRequest.contains("values"));
37190   //    assertTrue(GrouperClientWs.mostRecentRequest,
37191   //        !GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookup"));
37192   //    assertTrue(GrouperClientWs.mostRecentRequest,
37193   //        GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookup")
37194   //        && GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
37195   //    assertTrue(GrouperClientWs.mostRecentRequest,
37196   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookup"));
37197   //    assertTrue(GrouperClientWs.mostRecentRequest,
37198   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookup"));
37199   //    assertTrue(GrouperClientWs.mostRecentRequest,
37200   //        GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookup")
37201   //        && GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
37202   //    assertTrue(GrouperClientWs.mostRecentRequest,
37203   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookup"));
37204   //    assertTrue(GrouperClientWs.mostRecentRequest,
37205   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookup"));
37206   //    assertTrue(GrouperClientWs.mostRecentRequest,
37207   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookup"));
37208   //    assertTrue(GrouperClientWs.mostRecentRequest,
37209   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookup"));
37210   //
37211   //
37212   //    // ######################################################
37213   //    // attribute assign lookups
37214   //
37215   //    baos = new ByteArrayOutputStream();
37216   //    System.setOut(new PrintStream(baos));
37217   //
37218   //    attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, true);
37219   //
37220   //    String attributeAssignId = attributeAssign.getId();
37221   //
37222   //    GrouperClient.main(GrouperClientUtils.splitTrim(
37223   //        "--operation=assignAttributesBatchWs --entry_0_attributeAssignType=group --entry_0_attributeAssignOperation=remove_attr "
37224   //        + " --attributeAssignUuids=" + attributeAssign.getId(),
37225   //        " "));
37226   //
37227   //    attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, false);
37228   //
37229   //    assertNull("Should be deleted", attributeAssign);
37230   //
37231   //    System.out.flush();
37232   //    output = new String(baos.toByteArray());
37233   //
37234   //    System.setOut(systemOut);
37235   //
37236   //    outputLines = GrouperClientUtils.splitTrim(output, "\n");
37237   //
37238   //    outputLine = outputLines[0];
37239   //
37240   //    matcher = pattern.matcher(outputLines[0]);
37241   //
37242   //    assertTrue(outputLine, matcher.matches());
37243   //    assertEquals(outputLine, "0", matcher.group(1));
37244   //    assertEquals(outputLine, "0", matcher.group(2));
37245   //    assertEquals(outputLine, "group", matcher.group(3));
37246   //    assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(4));
37247   //    assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(5));
37248   //    assertEquals(outputLine, "assign", matcher.group(6));
37249   //    assertEquals(outputLine, "none", matcher.group(7));
37250   //    assertEquals(outputLine, "T", matcher.group(8));
37251   //    assertEquals(outputLine, attributeAssignId, matcher.group(9));
37252   //    assertEquals(outputLine, "T", matcher.group(10));
37253   //    assertEquals(outputLine, "T", matcher.group(11));
37254   //    assertEquals(outputLine, "F", matcher.group(12));
37255   //
37256   //    assertTrue(GrouperClientWs.mostRecentRequest,
37257   //        !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
37258   //    assertTrue(GrouperClientWs.mostRecentRequest,
37259   //        !GrouperClientWs.mostRecentRequest.contains("action"));
37260   //    assertTrue(GrouperClientWs.mostRecentRequest,
37261   //        !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
37262   //    assertTrue(GrouperClientWs.mostRecentRequest,
37263   //        !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
37264   //    assertTrue(GrouperClientWs.mostRecentRequest,
37265   //        !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
37266   //    assertTrue(GrouperClientWs.mostRecentRequest,
37267   //        GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
37268   //    assertTrue(GrouperClientWs.mostRecentRequest,
37269   //        !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
37270   //    assertTrue(GrouperClientWs.mostRecentRequest,
37271   //        GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
37272   //    assertTrue(GrouperClientWs.mostRecentRequest,
37273   //        !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
37274   //    assertTrue(GrouperClientWs.mostRecentRequest,
37275   //        !GrouperClientWs.mostRecentRequest.contains("delegatable"));
37276   //    assertTrue(GrouperClientWs.mostRecentRequest,
37277   //        !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
37278   //    assertTrue(GrouperClientWs.mostRecentRequest,
37279   //        !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
37280   //    assertTrue(GrouperClientWs.mostRecentRequest,
37281   //        !GrouperClientWs.mostRecentRequest.contains("params"));
37282   //    assertTrue(GrouperClientWs.mostRecentRequest,
37283   //        !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
37284   //    assertTrue(GrouperClientWs.mostRecentRequest,
37285   //        !GrouperClientWs.mostRecentRequest.contains("values"));
37286   //    assertTrue(GrouperClientWs.mostRecentRequest,
37287   //        GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookup"));
37288   //    assertTrue(GrouperClientWs.mostRecentRequest,
37289   //        !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookup")
37290   //        && !GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
37291   //    assertTrue(GrouperClientWs.mostRecentRequest,
37292   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookup"));
37293   //    assertTrue(GrouperClientWs.mostRecentRequest,
37294   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookup"));
37295   //    assertTrue(GrouperClientWs.mostRecentRequest,
37296   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookup")
37297   //        && !GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
37298   //    assertTrue(GrouperClientWs.mostRecentRequest,
37299   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookup"));
37300   //    assertTrue(GrouperClientWs.mostRecentRequest,
37301   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookup"));
37302   //    assertTrue(GrouperClientWs.mostRecentRequest,
37303   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookup"));
37304   //    assertTrue(GrouperClientWs.mostRecentRequest,
37305   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookup"));
37306   //
37307   //    // ######################################################
37308   //    // attribute assign lookups custom tempplate
37309   //
37310   //    baos = new ByteArrayOutputStream();
37311   //    System.setOut(new PrintStream(baos));
37312   //
37313   //    attributeAssign = group.getAttributeDelegate().assignAttribute(attributeDefName).getAttributeAssign();
37314   //
37315   //    attributeAssignId = attributeAssign.getId();
37316   //
37317   //    GrouperClient.main(GrouperClientUtils.splitTrim(
37318   //        "--operation=assignAttributesBatchWs --entry_0_attributeAssignType=group --entry_0_attributeAssignOperation=remove_attr "
37319   //        + " --attributeAssignUuids=" + attributeAssign.getId() + " --outputTemplate=${wsAttributeAssign.attributeAssignType}$newline$",
37320   //        " "));
37321   //
37322   //    attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, false);
37323   //
37324   //    assertNull("Should be deleted", attributeAssign);
37325   //
37326   //    System.out.flush();
37327   //    output = new String(baos.toByteArray());
37328   //
37329   //    System.setOut(systemOut);
37330   //
37331   //    outputLines = GrouperClientUtils.splitTrim(output, "\n");
37332   //
37333   //    outputLine = GrouperClientUtils.trim(outputLines[0]);
37334   //
37335   //    assertEquals(outputLine, "group", outputLine);
37336   //
37337   //    assertTrue(GrouperClientWs.mostRecentRequest,
37338   //        !GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
37339   //    assertTrue(GrouperClientWs.mostRecentRequest,
37340   //        !GrouperClientWs.mostRecentRequest.contains("action"));
37341   //    assertTrue(GrouperClientWs.mostRecentRequest,
37342   //        !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
37343   //    assertTrue(GrouperClientWs.mostRecentRequest,
37344   //        !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
37345   //    assertTrue(GrouperClientWs.mostRecentRequest,
37346   //        !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
37347   //    assertTrue(GrouperClientWs.mostRecentRequest,
37348   //        GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
37349   //    assertTrue(GrouperClientWs.mostRecentRequest,
37350   //        !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
37351   //    assertTrue(GrouperClientWs.mostRecentRequest,
37352   //        GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
37353   //    assertTrue(GrouperClientWs.mostRecentRequest,
37354   //        !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
37355   //    assertTrue(GrouperClientWs.mostRecentRequest,
37356   //        !GrouperClientWs.mostRecentRequest.contains("delegatable"));
37357   //    assertTrue(GrouperClientWs.mostRecentRequest,
37358   //        !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
37359   //    assertTrue(GrouperClientWs.mostRecentRequest,
37360   //        !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
37361   //    assertTrue(GrouperClientWs.mostRecentRequest,
37362   //        !GrouperClientWs.mostRecentRequest.contains("params"));
37363   //    assertTrue(GrouperClientWs.mostRecentRequest,
37364   //        !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
37365   //    assertTrue(GrouperClientWs.mostRecentRequest,
37366   //        !GrouperClientWs.mostRecentRequest.contains("values"));
37367   //    assertTrue(GrouperClientWs.mostRecentRequest,
37368   //        GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookup"));
37369   //    assertTrue(GrouperClientWs.mostRecentRequest,
37370   //        !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookup")
37371   //        && !GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
37372   //    assertTrue(GrouperClientWs.mostRecentRequest,
37373   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookup"));
37374   //    assertTrue(GrouperClientWs.mostRecentRequest,
37375   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookup"));
37376   //    assertTrue(GrouperClientWs.mostRecentRequest,
37377   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookup")
37378   //        && !GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
37379   //    assertTrue(GrouperClientWs.mostRecentRequest,
37380   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookup"));
37381   //    assertTrue(GrouperClientWs.mostRecentRequest,
37382   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookup"));
37383   //    assertTrue(GrouperClientWs.mostRecentRequest,
37384   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookup"));
37385   //    assertTrue(GrouperClientWs.mostRecentRequest,
37386   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookup"));
37387   //
37388   //
37389   //    // ######################################################
37390   //    // attribute assign lookups
37391   //
37392   //    baos = new ByteArrayOutputStream();
37393   //    System.setOut(new PrintStream(baos));
37394   //
37395   //    attributeAssign = group.getAttributeDelegate().assignAttribute(attributeDefName).getAttributeAssign();
37396   //
37397   //    attributeAssignId = attributeAssign.getId();
37398   //
37399   //    GrouperClient.main(GrouperClientUtils.splitTrim(
37400   //        "--operation=assignAttributesBatchWs --entry_0_attributeAssignType=group --entry_0_attributeAssignOperation=remove_attr "
37401   //        + " --attributeAssignUuids=" + attributeAssign.getId() + " --actAsSubjectId=GrouperSystem",
37402   //        " "));
37403   //
37404   //    attributeAssign = group.getAttributeDelegate().retrieveAssignment("assign", attributeDefName, false, false);
37405   //
37406   //    assertNull("Should be deleted", attributeAssign);
37407   //
37408   //    System.out.flush();
37409   //    output = new String(baos.toByteArray());
37410   //
37411   //    System.setOut(systemOut);
37412   //
37413   //    outputLines = GrouperClientUtils.splitTrim(output, "\n");
37414   //
37415   //    outputLine = outputLines[0];
37416   //
37417   //    matcher = pattern.matcher(outputLines[0]);
37418   //
37419   //    assertTrue(outputLine, matcher.matches());
37420   //    assertEquals(outputLine, "0", matcher.group(1));
37421   //    assertEquals(outputLine, "0", matcher.group(2));
37422   //    assertEquals(outputLine, "group", matcher.group(3));
37423   //    assertEquals(outputLine, "test:groupTestAttrAssign", matcher.group(4));
37424   //    assertEquals(outputLine, "test:testAttributeAssignDefName", matcher.group(5));
37425   //    assertEquals(outputLine, "assign", matcher.group(6));
37426   //    assertEquals(outputLine, "none", matcher.group(7));
37427   //    assertEquals(outputLine, "T", matcher.group(8));
37428   //    assertEquals(outputLine, attributeAssignId, matcher.group(9));
37429   //    assertEquals(outputLine, "T", matcher.group(10));
37430   //    assertEquals(outputLine, "T", matcher.group(11));
37431   //    assertEquals(outputLine, "F", matcher.group(12));
37432   //
37433   //    assertTrue(GrouperClientWs.mostRecentRequest,
37434   //        GrouperClientWs.mostRecentRequest.contains("actAsSubjectLookup"));
37435   //    assertTrue(GrouperClientWs.mostRecentRequest,
37436   //        !GrouperClientWs.mostRecentRequest.contains("action"));
37437   //    assertTrue(GrouperClientWs.mostRecentRequest,
37438   //        !GrouperClientWs.mostRecentRequest.contains("assignmentEnabledTime"));
37439   //    assertTrue(GrouperClientWs.mostRecentRequest,
37440   //        !GrouperClientWs.mostRecentRequest.contains("assignmentDisabledTime"));
37441   //    assertTrue(GrouperClientWs.mostRecentRequest,
37442   //        !GrouperClientWs.mostRecentRequest.contains("assignmentNotes"));
37443   //    assertTrue(GrouperClientWs.mostRecentRequest,
37444   //        GrouperClientWs.mostRecentRequest.contains("attributeAssignOperation"));
37445   //    assertTrue(GrouperClientWs.mostRecentRequest,
37446   //        !GrouperClientWs.mostRecentRequest.contains("attributeAssignValueOperation"));
37447   //    assertTrue(GrouperClientWs.mostRecentRequest,
37448   //        GrouperClientWs.mostRecentRequest.contains("attributeAssignType"));
37449   //    assertTrue(GrouperClientWs.mostRecentRequest,
37450   //        !GrouperClientWs.mostRecentRequest.contains("clientVersion"));
37451   //    assertTrue(GrouperClientWs.mostRecentRequest,
37452   //        !GrouperClientWs.mostRecentRequest.contains("delegatable"));
37453   //    assertTrue(GrouperClientWs.mostRecentRequest,
37454   //        !GrouperClientWs.mostRecentRequest.contains("includeGroupDetail"));
37455   //    assertTrue(GrouperClientWs.mostRecentRequest,
37456   //        !GrouperClientWs.mostRecentRequest.contains("includeSubjectDetail"));
37457   //    assertTrue(GrouperClientWs.mostRecentRequest,
37458   //        !GrouperClientWs.mostRecentRequest.contains("params"));
37459   //    assertTrue(GrouperClientWs.mostRecentRequest,
37460   //        !GrouperClientWs.mostRecentRequest.contains("subjectAttributeNames"));
37461   //    assertTrue(GrouperClientWs.mostRecentRequest,
37462   //        !GrouperClientWs.mostRecentRequest.contains("values"));
37463   //    assertTrue(GrouperClientWs.mostRecentRequest,
37464   //        GrouperClientWs.mostRecentRequest.contains("wsAttributeAssignLookup"));
37465   //    assertTrue(GrouperClientWs.mostRecentRequest,
37466   //        !GrouperClientWs.mostRecentRequest.contains("wsAttributeDefNameLookup")
37467   //        && !GrouperClientWs.mostRecentRequest.contains("test:testAttributeAssignDefName"));
37468   //    assertTrue(GrouperClientWs.mostRecentRequest,
37469   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeAssignLookup"));
37470   //    assertTrue(GrouperClientWs.mostRecentRequest,
37471   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerAttributeDefLookup"));
37472   //    assertTrue(GrouperClientWs.mostRecentRequest,
37473   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerGroupLookup")
37474   //        && !GrouperClientWs.mostRecentRequest.contains("test:groupTestAttrAssign"));
37475   //    assertTrue(GrouperClientWs.mostRecentRequest,
37476   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipAnyLookup"));
37477   //    assertTrue(GrouperClientWs.mostRecentRequest,
37478   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerMembershipLookup"));
37479   //    assertTrue(GrouperClientWs.mostRecentRequest,
37480   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerStemLookup"));
37481   //    assertTrue(GrouperClientWs.mostRecentRequest,
37482   //        !GrouperClientWs.mostRecentRequest.contains("wsOwnerSubjectLookup"));
37483 
37484 
37485 
37486     } finally {
37487       System.setOut(systemOut);
37488     }
37489 
37490   }
37491 
37492   /**
37493    * @throws Exception
37494    */
37495   public void testFindAttributeDefNamesServiceRole() throws Exception {
37496 
37497     PrintStream systemOut = System.out;
37498 
37499     ByteArrayOutputStream baos = new ByteArrayOutputStream();
37500     System.setOut(new PrintStream(baos));
37501     String output = null;
37502     String[] outputLines = null;
37503     Pattern pattern = null;
37504     Matcher matcher = null;
37505     try {
37506 
37507       GrouperSession grouperSession = GrouperSession.startRootSession();
37508 
37509       AttributeDefName jiraService = null;
37510       AttributeDefName confluenceService = null;
37511       try {
37512 
37513         //create three services, one directly in, one hierarchical, one the user is not in
37514         AttributeDef jiraServiceDef = new AttributeDefSave(grouperSession)
37515           .assignCreateParentStemsIfNotExist(true).assignAttributeDefType(AttributeDefType.service)
37516           .assignName("apps:jira:jiraServiceDefinition").assignToStem(true).save();
37517 
37518         jiraService = new AttributeDefNameSave(grouperSession, jiraServiceDef)
37519           .assignCreateParentStemsIfNotExist(true)
37520           .assignName("apps:jira:jiraService").assignDisplayExtension("Central IT production Jira issue tracker").save();
37521 
37522         //jira group
37523         Group jiraGroup = new GroupSave(grouperSession)
37524           .assignName("apps:jira:groups:admins").assignCreateParentStemsIfNotExist(true).save();
37525 
37526         jiraGroup.revokePriv(SubjectFinder.findAllSubject(), AccessPrivilege.READ);
37527         jiraGroup.grantPriv(SubjectTestHelper.SUBJ5, AccessPrivilege.READ);
37528         jiraGroup.grantPriv(SubjectTestHelper.SUBJ6, AccessPrivilege.ADMIN);
37529 
37530         jiraGroup.addMember(SubjectTestHelper.SUBJ0);
37531         jiraGroup.addMember(SubjectTestHelper.SUBJ1);
37532 
37533         //the jira group has the jira service tag
37534         Stem jiraStem = StemFinder.findByUuid(grouperSession, jiraGroup.getStemId(), true);
37535         jiraStem.getAttributeDelegate().assignAttribute(jiraService);
37536 
37537         AttributeDef confluenceServiceDef = new AttributeDefSave(grouperSession)
37538           .assignCreateParentStemsIfNotExist(true).assignAttributeDefType(AttributeDefType.service)
37539           .assignName("apps:confluence:confluenceServiceDefinition").assignToStem(true).save();
37540 
37541         confluenceService = new AttributeDefNameSave(grouperSession, confluenceServiceDef)
37542           .assignCreateParentStemsIfNotExist(true)
37543           .assignName("apps:confluence:confluenceService").assignDisplayExtension("Central IT production Confluence wiki").save();
37544 
37545         Group confluenceGroup = new GroupSave(grouperSession)
37546           .assignName("apps:confluence:editors").assignCreateParentStemsIfNotExist(true).save();
37547 
37548         confluenceGroup.revokePriv(SubjectFinder.findAllSubject(), AccessPrivilege.READ);
37549         confluenceGroup.grantPriv(SubjectTestHelper.SUBJ6, AccessPrivilege.READ);
37550         confluenceGroup.grantPriv(SubjectTestHelper.SUBJ7, AccessPrivilege.ADMIN);
37551         confluenceGroup.grantPriv(SubjectTestHelper.SUBJ8, AccessPrivilege.ADMIN);
37552 
37553         confluenceGroup.addMember(SubjectTestHelper.SUBJ1);
37554         confluenceGroup.addMember(SubjectTestHelper.SUBJ2);
37555 
37556         //the confluence folder has the confluence service tag
37557         Stem confluenceFolder = StemFinder.findByName(grouperSession, "apps:confluence", true);
37558         confluenceFolder.getAttributeDelegate().assignAttribute(confluenceService);
37559 
37560       } finally {
37561         GrouperSession.stopQuietly(grouperSession);
37562       }
37563 
37564       // ##################### subject 0 is in the jira service...
37565 
37566       GrouperClient.main(GrouperClientUtils.splitTrim(
37567           "--operation=findAttributeDefNamesWs --scope=% --serviceRole=user --subjectId=" + SubjectTestHelper.SUBJ0_ID , " "));
37568       System.out.flush();
37569       output = new String(baos.toByteArray());
37570 
37571       systemOut.println(output);
37572 
37573       System.setOut(systemOut);
37574 
37575       outputLines = GrouperClientUtils.splitTrim(output, "\n");
37576 
37577       assertEquals(1, outputLines.length);
37578 
37579       //Index ${index}: name: ${wsAttributeDefName.name}, displayName: ${wsAttributeDefName.displayName}$newline$
37580       pattern = Pattern.compile("^Index (\\d+): name: (.*), displayName: (.*)$");
37581       matcher = pattern.matcher(outputLines[0]);
37582 
37583       assertTrue(outputLines[0], matcher.matches());
37584 
37585       assertEquals(outputLines[0], "0", matcher.group(1));
37586       assertEquals(outputLines[0], jiraService.getName(), matcher.group(2));
37587       assertEquals(outputLines[0], jiraService.getDisplayName(), matcher.group(3));
37588 
37589       assertTrue(GrouperClientWs.mostRecentRequest,
37590           GrouperClientWs.mostRecentRequest.contains("serviceRole"));
37591       assertTrue(GrouperClientWs.mostRecentRequest,
37592           GrouperClientWs.mostRecentRequest.contains("<subjectId>"));
37593 
37594       // ##################### subject 1 is in the jira and confluence service...
37595 
37596       baos = new ByteArrayOutputStream();
37597 
37598       System.setOut(new PrintStream(baos));
37599 
37600       GrouperClient.main(GrouperClientUtils.splitTrim(
37601           "--operation=findAttributeDefNamesWs --scope=% --serviceRole=user --subjectIdentifier=" + SubjectTestHelper.SUBJ1_IDENTIFIER + " --subjectSource=jdbc" , " "));
37602       System.out.flush();
37603       output = new String(baos.toByteArray());
37604 
37605       systemOut.println(output);
37606 
37607       System.setOut(systemOut);
37608 
37609       outputLines = GrouperClientUtils.splitTrim(output, "\n");
37610 
37611       assertEquals(2, outputLines.length);
37612 
37613       //Index ${index}: name: ${wsAttributeDefName.name}, displayName: ${wsAttributeDefName.displayName}$newline$
37614       pattern = Pattern.compile("^Index (\\d+): name: (.*), displayName: (.*)$");
37615       matcher = pattern.matcher(outputLines[0]);
37616 
37617       assertTrue(outputLines[0], matcher.matches());
37618 
37619       assertEquals(outputLines[0], "0", matcher.group(1));
37620       assertEquals(outputLines[0], confluenceService.getName(), matcher.group(2));
37621       assertEquals(outputLines[0], confluenceService.getDisplayName(), matcher.group(3));
37622 
37623       matcher = pattern.matcher(outputLines[1]);
37624       assertTrue(outputLines[1], matcher.matches());
37625 
37626       assertEquals(outputLines[1], "1", matcher.group(1));
37627       assertEquals(outputLines[1], jiraService.getName(), matcher.group(2));
37628       assertEquals(outputLines[1], jiraService.getDisplayName(), matcher.group(3));
37629 
37630       assertTrue(GrouperClientWs.mostRecentRequest,
37631           GrouperClientWs.mostRecentRequest.contains("serviceRole"));
37632       assertTrue(GrouperClientWs.mostRecentRequest,
37633           GrouperClientWs.mostRecentRequest.contains("subjectIdentifier"));
37634       assertFalse(GrouperClientWs.mostRecentRequest,
37635           GrouperClientWs.mostRecentRequest.contains("<subjectId>"));
37636       assertTrue(GrouperClientWs.mostRecentRequest,
37637           GrouperClientWs.mostRecentRequest.contains("subjectSourceId"));
37638 
37639 
37640 
37641     } finally {
37642       System.setOut(systemOut);
37643     }
37644 
37645   }
37646   
37647   /**
37648    * @throws Exception
37649    */
37650   public void testAttributeDefSave() throws Exception {
37651 
37652     PrintStream systemOut = System.out;
37653 
37654     ByteArrayOutputStream baos = new ByteArrayOutputStream();
37655     System.setOut(new PrintStream(baos));
37656     String output = null;
37657     String[] outputLines = null;
37658     Pattern pattern = null;
37659     Matcher matcher = null;
37660     try {
37661 
37662       GrouperSession grouperSession = GrouperSession.startRootSession();
37663 
37664       GrouperClient.main(GrouperClientUtils.splitTrim(
37665           "--operation=attributeDefSaveWs --name=aStem:newAttributeDef --createParentStemsIfNotExist=T --attributeDefType=attr --valueType=string --assignToAttributeDef=T",
37666           " "));
37667       System.out.flush();
37668       output = new String(baos.toByteArray());
37669 
37670       systemOut.println(output);
37671 
37672       System.setOut(systemOut);
37673 
37674       outputLines = GrouperClientUtils.splitTrim(output, "\n");
37675 
37676       assertEquals(1, outputLines.length);
37677 
37678       pattern = Pattern.compile("^Success: (T|F): code: ([A-Z_]+): (.*+)$");
37679       matcher = pattern.matcher(outputLines[0]);
37680 
37681       assertTrue(outputLines[0], matcher.matches());
37682 
37683       assertEquals(outputLines[0], "T", matcher.group(1));
37684       assertEquals(outputLines[0], "SUCCESS_INSERTED", matcher.group(2));
37685       assertEquals(outputLines[0], "aStem:newAttributeDef", matcher.group(3));
37686 
37687       // ##########################
37688       //try with name with slash
37689 
37690       baos = new ByteArrayOutputStream();
37691       System.setOut(new PrintStream(baos));
37692 
37693       GrouperClient.main(GrouperClientUtils.splitTrim(
37694           "--operation=attributeDefSaveWs --name=aStem:newAttributeDef0/1 --createParentStemsIfNotExist=T --attributeDefType=attr --valueType=string --assignToAttributeDef=T",
37695           " "));
37696 
37697       System.out.flush();
37698       output = new String(baos.toByteArray());
37699 
37700       System.setOut(systemOut);
37701 
37702       outputLines = GrouperClientUtils.splitTrim(output, "\n");
37703 
37704       assertEquals(1, outputLines.length);
37705 
37706       matcher = pattern.matcher(outputLines[0]);
37707 
37708       assertTrue(outputLines[0], matcher.matches());
37709 
37710       assertEquals(outputLines[0], "T", matcher.group(1));
37711       assertEquals(outputLines[0], "SUCCESS_INSERTED", matcher.group(2));
37712       assertEquals(outputLines[0], "aStem:newAttributeDef0/1", matcher.group(3));
37713 
37714       assertFalse(GrouperClientWs.mostRecentRequest,
37715           GrouperClientWs.mostRecentRequest.contains("saveMode"));
37716 
37717       //########################################################
37718       // run again with save mode  --saveMode=INSERT_OR_UPDATE|INSERT|UPDATE
37719 
37720       baos = new ByteArrayOutputStream();
37721       System.setOut(new PrintStream(baos));
37722 
37723       GrouperClient.main(GrouperClientUtils.splitTrim(
37724           "--operation=attributeDefSaveWs --name=aStem:newAttributeDef0/1 --createParentStemsIfNotExist=T "
37725               + "--attributeDefType=attr --valueType=string --assignToAttributeDef=T --saveMode=UPDATE",
37726           " "));
37727 
37728       System.out.flush();
37729       output = new String(baos.toByteArray());
37730 
37731       System.setOut(systemOut);
37732 
37733       outputLines = GrouperClientUtils.splitTrim(output, "\n");
37734 
37735       assertEquals(1, outputLines.length);
37736 
37737       matcher = pattern.matcher(outputLines[0]);
37738 
37739       assertTrue(outputLines[0], matcher.matches());
37740 
37741       assertEquals(outputLines[0], "T", matcher.group(1));
37742       assertEquals(outputLines[0], "SUCCESS_NO_CHANGES_NEEDED", matcher.group(2));
37743       assertEquals(outputLines[0], "aStem:newAttributeDef0/1", matcher.group(3));
37744 
37745       assertTrue(GrouperClientWs.mostRecentRequest,
37746           GrouperClientWs.mostRecentRequest.contains("saveMode")
37747               && GrouperClientWs.mostRecentRequest.contains(">UPDATE<"));
37748       assertFalse(GrouperClientWs.mostRecentRequest,
37749           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookup"));
37750 
37751       //########################################################
37752       // run again with lookup  --attributeDefLookupName=aStem:newAttributeDef
37753 
37754       baos = new ByteArrayOutputStream();
37755       System.setOut(new PrintStream(baos));
37756 
37757       GrouperClient.main(GrouperClientUtils.splitTrim(
37758           "--operation=attributeDefSaveWs --name=aStem:newAttributeDef --createParentStemsIfNotExist=T "
37759               + "--attributeDefLookupName=aStem:newAttributeDef --attributeDefType=attr --valueType=string --assignToAttributeDef=T",
37760           " "));
37761 
37762       System.out.flush();
37763       output = new String(baos.toByteArray());
37764 
37765       System.setOut(systemOut);
37766 
37767       outputLines = GrouperClientUtils.splitTrim(output, "\n");
37768 
37769       assertEquals(1, outputLines.length);
37770 
37771       matcher = pattern.matcher(outputLines[0]);
37772 
37773       assertTrue(outputLines[0], matcher.matches());
37774 
37775       assertEquals(outputLines[0], "T", matcher.group(1));
37776       assertEquals(outputLines[0], "SUCCESS_NO_CHANGES_NEEDED", matcher.group(2));
37777       assertEquals(outputLines[0], "aStem:newAttributeDef", matcher.group(3));
37778 
37779       assertFalse(GrouperClientWs.mostRecentRequest,
37780           GrouperClientWs.mostRecentRequest.contains("saveMode"));
37781       assertTrue(GrouperClientWs.mostRecentRequest,
37782           GrouperClientWs.mostRecentRequest.contains("createParentStemsIfNotExist"));
37783       assertTrue(GrouperClientWs.mostRecentRequest,
37784           GrouperClientWs.mostRecentRequest.contains("<wsAttributeDefLookup>"));
37785 
37786       //########################################################
37787       // run again with lookup  --attributeDefLookupUuid=aStem:newAttributeDef
37788 
37789       AttributeDef newAttributeDef = AttributeDefFinder
37790           .findByName("aStem:newAttributeDef", true);
37791 
37792       baos = new ByteArrayOutputStream();
37793       System.setOut(new PrintStream(baos));
37794 
37795       GrouperClient.main(GrouperClientUtils.splitTrim(
37796           "--operation=attributeDefSaveWs --name=aStem:newAttributeDef --createParentStemsIfNotExist=T "
37797               + "--attributeDefLookupUuid=" + newAttributeDef.getId()
37798               + " --attributeDefType=attr --valueType=string --assignToAttributeDef=T",
37799           " "));
37800 
37801       System.out.flush();
37802       output = new String(baos.toByteArray());
37803 
37804       System.setOut(systemOut);
37805 
37806       outputLines = GrouperClientUtils.splitTrim(output, "\n");
37807 
37808       assertEquals(1, outputLines.length);
37809 
37810       matcher = pattern.matcher(outputLines[0]);
37811 
37812       assertTrue(outputLines[0], matcher.matches());
37813 
37814       assertEquals(outputLines[0], "T", matcher.group(1));
37815       assertEquals(outputLines[0], "SUCCESS_NO_CHANGES_NEEDED", matcher.group(2));
37816       assertEquals(outputLines[0], "aStem:newAttributeDef", matcher.group(3));
37817 
37818       assertFalse(GrouperClientWs.mostRecentRequest,
37819           GrouperClientWs.mostRecentRequest.contains("description"));
37820       assertTrue(GrouperClientWs.mostRecentRequest,
37821           GrouperClientWs.mostRecentRequest.contains("<wsAttributeDefLookup>")
37822               && GrouperClientWs.mostRecentRequest.contains(newAttributeDef.getId()));
37823 
37824       //########################################################
37825       // run again with lookup  --attributeDefLookupUuid=aStem:newAttributeDef
37826 
37827       baos = new ByteArrayOutputStream();
37828       System.setOut(new PrintStream(baos));
37829 
37830       GrouperClient.main(GrouperClientUtils.splitTrim(
37831           "--operation=attributeDefSaveWs --name=aStem:newAttributeDef --createParentStemsIfNotExist=T "
37832               + "--attributeDefLookupIdIndex=" + newAttributeDef.getIdIndex()
37833               + " --attributeDefType=attr --valueType=string --assignToAttributeDef=T",
37834           " "));
37835 
37836       System.out.flush();
37837       output = new String(baos.toByteArray());
37838 
37839       System.setOut(systemOut);
37840 
37841       outputLines = GrouperClientUtils.splitTrim(output, "\n");
37842 
37843       assertEquals(1, outputLines.length);
37844 
37845       matcher = pattern.matcher(outputLines[0]);
37846 
37847       assertTrue(outputLines[0], matcher.matches());
37848 
37849       assertEquals(outputLines[0], "T", matcher.group(1));
37850       assertEquals(outputLines[0], "SUCCESS_NO_CHANGES_NEEDED", matcher.group(2));
37851       assertEquals(outputLines[0], "aStem:newAttributeDef", matcher.group(3));
37852 
37853       assertFalse(GrouperClientWs.mostRecentRequest,
37854           GrouperClientWs.mostRecentRequest.contains("description"));
37855       assertTrue(GrouperClientWs.mostRecentRequest,
37856           GrouperClientWs.mostRecentRequest.contains("<wsAttributeDefLookup>")
37857               && GrouperClientWs.mostRecentRequest
37858                   .contains(newAttributeDef.getIdIndex().toString()));
37859 
37860       //########################################################
37861       // run again with --description=theDescription
37862 
37863       baos = new ByteArrayOutputStream();
37864       System.setOut(new PrintStream(baos));
37865 
37866       GrouperClient.main(GrouperClientUtils.splitTrim(
37867           "--operation=attributeDefSaveWs --name=aStem:newAttributeDef --createParentStemsIfNotExist=T "
37868               + "--description=theDescription --attributeDefType=attr --valueType=string --assignToAttributeDef=T",
37869           " "));
37870 
37871       System.out.flush();
37872       output = new String(baos.toByteArray());
37873 
37874       System.setOut(systemOut);
37875 
37876       outputLines = GrouperClientUtils.splitTrim(output, "\n");
37877 
37878       assertEquals(1, outputLines.length);
37879 
37880       matcher = pattern.matcher(outputLines[0]);
37881 
37882       assertTrue(outputLines[0], matcher.matches());
37883 
37884       assertEquals(outputLines[0], "T", matcher.group(1));
37885       assertEquals(outputLines[0], "SUCCESS_UPDATED", matcher.group(2));
37886       assertEquals(outputLines[0], "aStem:newAttributeDef", matcher.group(3));
37887 
37888       assertTrue(GrouperClientWs.mostRecentRequest,
37889           GrouperClientWs.mostRecentRequest.contains("<description>")
37890               && GrouperClientWs.mostRecentRequest.contains("theDescription"));
37891 
37892       //########################################################
37893       // run again with --idIndex=12345
37894 
37895       baos = new ByteArrayOutputStream();
37896       System.setOut(new PrintStream(baos));
37897 
37898       GrouperClient.main(GrouperClientUtils.splitTrim(
37899           "--operation=attributeDefSaveWs --name=aStem:newAttributeDef5 --idIndex=12345 --createParentStemsIfNotExist=T "
37900               + "--description=theDescription --attributeDefType=attr --valueType=string --assignToAttributeDef=T",
37901           " "));
37902 
37903       System.out.flush();
37904       output = new String(baos.toByteArray());
37905 
37906       System.setOut(systemOut);
37907 
37908       outputLines = GrouperClientUtils.splitTrim(output, "\n");
37909 
37910       assertEquals(1, outputLines.length);
37911 
37912       matcher = pattern.matcher(outputLines[0]);
37913 
37914       assertTrue(outputLines[0], matcher.matches());
37915 
37916       assertEquals(outputLines[0], "T", matcher.group(1));
37917       assertEquals(outputLines[0], "SUCCESS_INSERTED", matcher.group(2));
37918       assertEquals(outputLines[0], "aStem:newAttributeDef5", matcher.group(3));
37919 
37920       assertTrue(GrouperClientWs.mostRecentRequest,
37921           GrouperClientWs.mostRecentRequest.contains("<idIndex>")
37922               && GrouperClientWs.mostRecentRequest.contains("12345"));
37923       assertTrue(GrouperClientWs.mostRecentResponse,
37924           GrouperClientWs.mostRecentResponse.contains("<idIndex>12345"));
37925 
37926       //########################################################
37927       // run again with --actAsSubjectId=subjId
37928 
37929       baos = new ByteArrayOutputStream();
37930       System.setOut(new PrintStream(baos));
37931 
37932       GrouperClient.main(GrouperClientUtils.splitTrim(
37933           "--operation=attributeDefSaveWs --name=aStem:newAttributeDef --actAsSubjectId=GrouperSystem --createParentStemsIfNotExist=T "
37934               + "--description=theDescription --attributeDefType=attr --valueType=string --assignToAttributeDef=T",
37935           " "));
37936 
37937       System.out.flush();
37938       output = new String(baos.toByteArray());
37939 
37940       System.setOut(systemOut);
37941 
37942       outputLines = GrouperClientUtils.splitTrim(output, "\n");
37943 
37944       assertEquals(1, outputLines.length);
37945 
37946       matcher = pattern.matcher(outputLines[0]);
37947 
37948       assertTrue(outputLines[0], matcher.matches());
37949 
37950       assertEquals(outputLines[0], "T", matcher.group(1));
37951       assertEquals(outputLines[0], "SUCCESS_NO_CHANGES_NEEDED", matcher.group(2));
37952       assertEquals(outputLines[0], "aStem:newAttributeDef", matcher.group(3));
37953 
37954       assertFalse(GrouperClientWs.mostRecentRequest,
37955           GrouperClientWs.mostRecentRequest.contains("subjectIdentifier"));
37956       assertTrue(GrouperClientWs.mostRecentRequest,
37957           GrouperClientWs.mostRecentRequest.contains("<actAsSubjectLookup><subjectId>"));
37958 
37959       //########################################################
37960       // run again with --actAsSubjectIdentifier=subjId
37961 
37962       baos = new ByteArrayOutputStream();
37963       System.setOut(new PrintStream(baos));
37964 
37965       GrouperClient.main(GrouperClientUtils.splitTrim(
37966           "--operation=attributeDefSaveWs --name=aStem:newAttributeDef --actAsSubjectIdentifier=GrouperSystem --createParentStemsIfNotExist=T "
37967               + "--description=theDescription --attributeDefType=attr --valueType=string --assignToAttributeDef=T",
37968           " "));
37969 
37970       System.out.flush();
37971       output = new String(baos.toByteArray());
37972 
37973       System.setOut(systemOut);
37974 
37975       outputLines = GrouperClientUtils.splitTrim(output, "\n");
37976 
37977       assertEquals(1, outputLines.length);
37978 
37979       matcher = pattern.matcher(outputLines[0]);
37980 
37981       assertTrue(outputLines[0], matcher.matches());
37982 
37983       assertEquals(outputLines[0], "T", matcher.group(1));
37984       assertEquals(outputLines[0], "SUCCESS_NO_CHANGES_NEEDED", matcher.group(2));
37985       assertEquals(outputLines[0], "aStem:newAttributeDef", matcher.group(3));
37986 
37987       assertFalse(GrouperClientWs.mostRecentRequest,
37988           GrouperClientWs.mostRecentRequest.contains("sourceId"));
37989       assertTrue(GrouperClientWs.mostRecentRequest,
37990           GrouperClientWs.mostRecentRequest
37991               .contains("<actAsSubjectLookup><subjectIdentifier>"));
37992 
37993       //########################################################
37994       // run again with --actAsSubjectSource=subjId
37995 
37996       baos = new ByteArrayOutputStream();
37997       System.setOut(new PrintStream(baos));
37998 
37999       GrouperClient.main(GrouperClientUtils.splitTrim(
38000           "--operation=attributeDefSaveWs --name=aStem:newAttributeDef --actAsSubjectIdentifier=GrouperSystem"
38001               + " --actAsSubjectSource=g:isa --createParentStemsIfNotExist=T"
38002               + " --description=theDescription --attributeDefType=attr --valueType=string --assignToAttributeDef=T",
38003           " "));
38004 
38005       System.out.flush();
38006       output = new String(baos.toByteArray());
38007 
38008       System.setOut(systemOut);
38009 
38010       outputLines = GrouperClientUtils.splitTrim(output, "\n");
38011 
38012       assertEquals(1, outputLines.length);
38013 
38014       matcher = pattern.matcher(outputLines[0]);
38015 
38016       assertTrue(outputLines[0], matcher.matches());
38017 
38018       assertEquals(outputLines[0], "T", matcher.group(1));
38019       assertEquals(outputLines[0], "SUCCESS_NO_CHANGES_NEEDED", matcher.group(2));
38020       assertEquals(outputLines[0], "aStem:newAttributeDef", matcher.group(3));
38021 
38022       assertFalse(GrouperClientWs.mostRecentRequest,
38023           GrouperClientWs.mostRecentRequest.contains("somethingelse"));
38024       assertTrue(GrouperClientWs.mostRecentRequest,
38025           GrouperClientWs.mostRecentRequest.contains("subjectSourceId")
38026               && GrouperClientWs.mostRecentRequest.contains("g:isa"));
38027 
38028     } finally {
38029       System.setOut(systemOut);
38030     }
38031 
38032   }
38033   
38034   /**
38035    * @throws Exception
38036    */
38037   public void testAttributeDefDelete() throws Exception {
38038 
38039     PrintStream systemOut = System.out;
38040 
38041     ByteArrayOutputStream baos = new ByteArrayOutputStream();
38042     System.setOut(new PrintStream(baos));
38043     String output = null;
38044     String[] outputLines = null;
38045     Pattern pattern = null;
38046     Matcher matcher = null;
38047     try {
38048 
38049       GrouperSession grouperSession = GrouperSession.startRootSession();
38050 
38051       AttributeDef testAttributeDef1 = new AttributeDefSave(grouperSession)
38052           .assignName("aStem:newAttributeDef")
38053           .assignAttributeDefType(AttributeDefType.perm).assignToGroup(true)
38054           .assignToEffMembership(true).save();
38055 
38056       GrouperClient.main(GrouperClientUtils.splitTrim(
38057           "--operation=attributeDefDeleteWs --attributeDefNames=aStem:newAttributeDef,aStem:newAttributeDef2",
38058           " "));
38059       System.out.flush();
38060       output = new String(baos.toByteArray());
38061 
38062       systemOut.println(output);
38063 
38064       System.setOut(systemOut);
38065 
38066       outputLines = GrouperClientUtils.splitTrim(output, "\n");
38067 
38068       assertEquals(2, outputLines.length);
38069 
38070       pattern = Pattern.compile("^Index (\\d+): success: (T|F): code: ([A-Z_]+): (.*+)$");
38071       matcher = pattern.matcher(outputLines[0]);
38072 
38073       assertTrue(outputLines[0], matcher.matches());
38074 
38075       assertEquals(outputLines[0], "0", matcher.group(1));
38076       assertEquals(outputLines[0], "T", matcher.group(2));
38077       assertEquals(outputLines[0], "SUCCESS", matcher.group(3));
38078       assertEquals(outputLines[0], "aStem:newAttributeDef", matcher.group(4));
38079 
38080       matcher = pattern.matcher(outputLines[1]);
38081 
38082       assertTrue(outputLines[1], matcher.matches());
38083 
38084       assertEquals(outputLines[1], "1", matcher.group(1));
38085       assertEquals(outputLines[1], "T", matcher.group(2));
38086       assertEquals(outputLines[1], "SUCCESS_ATTRIBUTE_DEF_NOT_FOUND", matcher.group(3));
38087       assertEquals(outputLines[1], "aStem:newAttributeDef2", matcher.group(4));
38088 
38089       // ##########################
38090       // [--txType=NONE|READ_WRITE_NEW]
38091       baos = new ByteArrayOutputStream();
38092       System.setOut(new PrintStream(baos));
38093 
38094       GrouperClient.main(GrouperClientUtils.splitTrim(
38095           "--operation=attributeDefDeleteWs --attributeDefNames=aStem:newAttributeDef,aStem:newAttributeDef2 --txType=READ_WRITE_NEW",
38096           " "));
38097 
38098       System.out.flush();
38099       output = new String(baos.toByteArray());
38100 
38101       System.setOut(systemOut);
38102 
38103       outputLines = GrouperClientUtils.splitTrim(output, "\n");
38104 
38105       assertEquals(2, outputLines.length);
38106 
38107       matcher = pattern.matcher(outputLines[0]);
38108 
38109       assertTrue(outputLines[0], matcher.matches());
38110 
38111       assertEquals(outputLines[0], "0", matcher.group(1));
38112       assertEquals(outputLines[0], "T", matcher.group(2));
38113       assertEquals(outputLines[0], "SUCCESS_ATTRIBUTE_DEF_NOT_FOUND", matcher.group(3));
38114       assertEquals(outputLines[0], "aStem:newAttributeDef", matcher.group(4));
38115 
38116       matcher = pattern.matcher(outputLines[1]);
38117 
38118       assertTrue(outputLines[1], matcher.matches());
38119 
38120       assertEquals(outputLines[1], "1", matcher.group(1));
38121       assertEquals(outputLines[1], "T", matcher.group(2));
38122       assertEquals(outputLines[1], "SUCCESS_ATTRIBUTE_DEF_NOT_FOUND", matcher.group(3));
38123       assertEquals(outputLines[1], "aStem:newAttributeDef2", matcher.group(4));
38124 
38125       assertTrue(GrouperClientWs.mostRecentRequest,
38126           GrouperClientWs.mostRecentRequest.contains("txType")
38127               && GrouperClientWs.mostRecentRequest.contains("READ_WRITE_NEW"));
38128 
38129     } finally {
38130       System.setOut(systemOut);
38131     }
38132 
38133   }
38134   
38135   /**
38136    * @throws Exception
38137    */
38138   public void testFindAttributeDefs() throws Exception {
38139 
38140     PrintStream systemOut = System.out;
38141 
38142     ByteArrayOutputStream baos = new ByteArrayOutputStream();
38143     System.setOut(new PrintStream(baos));
38144     String output = null;
38145     String[] outputLines = null;
38146     Pattern pattern = null;
38147     Matcher matcher = null;
38148     try {
38149 
38150       GrouperSession grouperSession = GrouperSession.startRootSession();
38151 
38152       AttributeDef attributeDef1 = new AttributeDefSave(grouperSession)
38153           .assignName("aStem1:newAttributeDef1")
38154           .assignCreateParentStemsIfNotExist(true)
38155           .assignAttributeDefType(AttributeDefType.perm).assignToGroup(true)
38156           .assignDescription("attribute def 1").save();
38157 
38158       AttributeDef attributeDef2 = new AttributeDefSave(grouperSession)
38159           .assignName("aStem1:newAttributeDef2")
38160           .assignCreateParentStemsIfNotExist(true)
38161           .assignAttributeDefType(AttributeDefType.perm).assignToGroup(true)
38162           .assignDescription("attribute def 2").save();
38163 
38164       GrouperClient.main(GrouperClientUtils.splitTrim(
38165           "--operation=findAttributeDefsWs --attributeDefNames=aStem1:newAttributeDef1,aStem1:newAttributeDef2 --scope=aStem",
38166           " "));
38167       System.out.flush();
38168       output = new String(baos.toByteArray());
38169 
38170       systemOut.println(output);
38171 
38172       System.setOut(systemOut);
38173 
38174       outputLines = GrouperClientUtils.splitTrim(output, "\n");
38175 
38176       assertEquals(2, outputLines.length);
38177 
38178       //Index ${index}: name: ${wsAttributeDef.name}, description: ${wsAttributeDef.description}$newline$
38179       pattern = Pattern.compile("^Index (\\d+): name: (.*), description: (.*)$");
38180       matcher = pattern.matcher(outputLines[0]);
38181 
38182       assertTrue(outputLines[0], matcher.matches());
38183 
38184       assertEquals(outputLines[0], "0", matcher.group(1));
38185       assertEquals(outputLines[0], "aStem1:newAttributeDef1", matcher.group(2));
38186       assertEquals(outputLines[0], "attribute def 1", matcher.group(3));
38187 
38188       assertTrue(GrouperClientWs.mostRecentRequest,
38189           GrouperClientWs.mostRecentRequest.contains("scope"));
38190       assertFalse(GrouperClientWs.mostRecentRequest,
38191           GrouperClientWs.mostRecentRequest.contains("splitScope"));
38192 
38193       // ############################
38194       //[--splitScope=T|F]
38195       baos = new ByteArrayOutputStream();
38196 
38197       System.setOut(new PrintStream(baos));
38198 
38199       GrouperClient.main(GrouperClientUtils.splitTrim(
38200           "--operation=findAttributeDefsWs --attributeDefNames=aStem1:newAttributeDef1,aStem1:newAttributeDef2 --scope=aStem --splitScope=T",
38201           " "));
38202       System.out.flush();
38203       output = new String(baos.toByteArray());
38204 
38205       systemOut.println(output);
38206 
38207       System.setOut(systemOut);
38208 
38209       outputLines = GrouperClientUtils.splitTrim(output, "\n");
38210 
38211       assertEquals(2, outputLines.length);
38212 
38213       //Index ${index}: name: ${wsAttributeDef.name}, description: ${wsAttributeDef.description}$newline$
38214       matcher = pattern.matcher(outputLines[0]);
38215 
38216       assertTrue(outputLines[0], matcher.matches());
38217 
38218       assertEquals(outputLines[0], "0", matcher.group(1));
38219       assertEquals(outputLines[0], "aStem1:newAttributeDef1", matcher.group(2));
38220       assertEquals(outputLines[0], "attribute def 1", matcher.group(3));
38221 
38222       assertTrue(GrouperClientWs.mostRecentRequest,
38223           GrouperClientWs.mostRecentRequest.contains("scope"));
38224       assertTrue(GrouperClientWs.mostRecentRequest,
38225           GrouperClientWs.mostRecentRequest.contains("splitScope"));
38226       assertTrue(GrouperClientWs.mostRecentRequest,
38227           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
38228 
38229       // ############################
38230       //[--attributeDefNames=a:b]
38231       baos = new ByteArrayOutputStream();
38232 
38233       System.setOut(new PrintStream(baos));
38234 
38235       GrouperClient.main(GrouperClientUtils.splitTrim(
38236           "--operation=findAttributeDefsWs --attributeDefNames=aStem1:newAttributeDef1,aStem1:newAttributeDef2",
38237           " "));
38238       System.out.flush();
38239       output = new String(baos.toByteArray());
38240 
38241       systemOut.println(output);
38242 
38243       System.setOut(systemOut);
38244 
38245       outputLines = GrouperClientUtils.splitTrim(output, "\n");
38246 
38247       assertEquals(2, outputLines.length);
38248 
38249       //Index ${index}: name: ${wsAttributeDef.name}, description: ${wsAttributeDef.description}$newline$
38250       matcher = pattern.matcher(outputLines[0]);
38251 
38252       assertTrue(outputLines[0], matcher.matches());
38253 
38254       assertEquals(outputLines[0], "0", matcher.group(1));
38255       assertEquals(outputLines[0], "aStem1:newAttributeDef1", matcher.group(2));
38256       assertEquals(outputLines[0], "attribute def 1", matcher.group(3));
38257 
38258       assertFalse(GrouperClientWs.mostRecentRequest,
38259           GrouperClientWs.mostRecentRequest.contains("scope"));
38260       assertFalse(GrouperClientWs.mostRecentRequest,
38261           GrouperClientWs.mostRecentRequest.contains("splitScope"));
38262       assertTrue(GrouperClientWs.mostRecentRequest,
38263           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
38264 
38265       // ############################
38266       //[--attributeDefUuids=12ab,34cd]
38267       baos = new ByteArrayOutputStream();
38268 
38269       System.setOut(new PrintStream(baos));
38270 
38271       GrouperClient.main(GrouperClientUtils.splitTrim(
38272           "--operation=findAttributeDefsWs --attributeDefUuids=" + attributeDef1.getId()
38273               + "," + attributeDef2.getId(),
38274           " "));
38275       System.out.flush();
38276       output = new String(baos.toByteArray());
38277 
38278       systemOut.println(output);
38279 
38280       System.setOut(systemOut);
38281 
38282       outputLines = GrouperClientUtils.splitTrim(output, "\n");
38283 
38284       assertEquals(2, outputLines.length);
38285 
38286       //Index ${index}: name: ${wsAttributeDef.name}, description: ${wsAttributeDef.description}$newline$
38287       matcher = pattern.matcher(outputLines[0]);
38288 
38289       assertTrue(outputLines[0], matcher.matches());
38290 
38291       assertEquals(outputLines[0], "0", matcher.group(1));
38292       assertEquals(outputLines[0], "aStem1:newAttributeDef1", matcher.group(2));
38293       assertEquals(outputLines[0], "attribute def 1", matcher.group(3));
38294 
38295       assertFalse(GrouperClientWs.mostRecentRequest,
38296           GrouperClientWs.mostRecentRequest.contains("scope"));
38297       assertFalse(GrouperClientWs.mostRecentRequest,
38298           GrouperClientWs.mostRecentRequest.contains("splitScope"));
38299       assertTrue(GrouperClientWs.mostRecentRequest,
38300           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
38301 
38302       // ############################
38303       //[--attributeDefIdIndexes=12,34]
38304       baos = new ByteArrayOutputStream();
38305 
38306       System.setOut(new PrintStream(baos));
38307 
38308       GrouperClient.main(GrouperClientUtils.splitTrim(
38309           "--operation=findAttributeDefsWs --attributeDefIdIndexes="
38310               + attributeDef1.getIdIndex() + "," + attributeDef2.getIdIndex(),
38311           " "));
38312       System.out.flush();
38313       output = new String(baos.toByteArray());
38314 
38315       systemOut.println(output);
38316 
38317       System.setOut(systemOut);
38318 
38319       outputLines = GrouperClientUtils.splitTrim(output, "\n");
38320 
38321       assertEquals(2, outputLines.length);
38322 
38323       //Index ${index}: name: ${wsAttributeDef.name}, description: ${wsAttributeDef.description}$newline$
38324       matcher = pattern.matcher(outputLines[0]);
38325 
38326       assertTrue(outputLines[0], matcher.matches());
38327 
38328       assertEquals(outputLines[0], "0", matcher.group(1));
38329       assertEquals(outputLines[0], "aStem1:newAttributeDef1", matcher.group(2));
38330       assertEquals(outputLines[0], "attribute def 1", matcher.group(3));
38331 
38332       assertFalse(GrouperClientWs.mostRecentRequest,
38333           GrouperClientWs.mostRecentRequest.contains("scope"));
38334       assertFalse(GrouperClientWs.mostRecentRequest,
38335           GrouperClientWs.mostRecentRequest.contains("splitScope"));
38336       assertTrue(GrouperClientWs.mostRecentRequest,
38337           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
38338 
38339       // ############################
38340       //[--sortString=name|extension|displayExtension] [--ascending=T|F] [--pageNumber=2] [--pageSize=50]
38341       baos = new ByteArrayOutputStream();
38342 
38343       System.setOut(new PrintStream(baos));
38344 
38345       GrouperClient.main(GrouperClientUtils.splitTrim(
38346           "--operation=findAttributeDefsWs --attributeDefNames=aStem1:newAttributeDef1,aStem1:newAttributeDef2 --scope=aStem --sortString=extension --ascending=T --pageNumber=2 --pageSize=1",
38347           " "));
38348       System.out.flush();
38349       output = new String(baos.toByteArray());
38350 
38351       systemOut.println(output);
38352 
38353       System.setOut(systemOut);
38354 
38355       outputLines = GrouperClientUtils.splitTrim(output, "\n");
38356 
38357       assertEquals(1, outputLines.length);
38358 
38359       //Index ${index}: name: ${wsAttributeDef.name}, description: ${wsAttributeDef.description}$newline$
38360       matcher = pattern.matcher(outputLines[0]);
38361 
38362       assertTrue(outputLines[0], matcher.matches());
38363 
38364       assertEquals(outputLines[0], "0", matcher.group(1));
38365       assertEquals(outputLines[0], "aStem1:newAttributeDef2", matcher.group(2));
38366       assertEquals(outputLines[0], "attribute def 2", matcher.group(3));
38367 
38368       assertTrue(GrouperClientWs.mostRecentRequest,
38369           GrouperClientWs.mostRecentRequest.contains("wsAttributeDefLookups"));
38370       assertTrue(GrouperClientWs.mostRecentRequest,
38371           GrouperClientWs.mostRecentRequest.contains("sortString"));
38372       assertTrue(GrouperClientWs.mostRecentRequest,
38373           GrouperClientWs.mostRecentRequest.contains("ascending"));
38374       assertTrue(GrouperClientWs.mostRecentRequest,
38375           GrouperClientWs.mostRecentRequest.contains("pageNumber"));
38376       assertTrue(GrouperClientWs.mostRecentRequest,
38377           GrouperClientWs.mostRecentRequest.contains("pageSize"));
38378 
38379     } finally {
38380       System.setOut(systemOut);
38381     }
38382 
38383   }
38384 
38385   /**
38386    * @throws Exception
38387    */
38388   public void testSendMessage() throws Exception {
38389 
38390     PrintStream systemOut = System.out;
38391 
38392     ByteArrayOutputStream baos = new ByteArrayOutputStream();
38393     System.setOut(new PrintStream(baos));
38394     String output = null;
38395     String[] outputLines = null;
38396     Pattern pattern = null;
38397     Matcher matcher = null;
38398     try {
38399 
38400       GrouperSession grouperSession = GrouperSession.startRootSession();
38401       GrouperBuiltinMessagingSystem.createQueue("test_queue");
38402       GrouperBuiltinMessagingSystem.allowSendToQueue("test_queue", SubjectTestHelper.SUBJ0);
38403       GrouperBuiltinMessagingSystem.allowReceiveFromQueue("test_queue", SubjectTestHelper.SUBJ0);
38404 
38405       GrouperClient.main(GrouperClientUtils.splitTrim(
38406           "--operation=sendMessageWs --queueOrTopic=queue --queueOrTopicName=test_queue --messages=Test_body,Another_test_body --actAsSubjectId="+SubjectTestHelper.SUBJ0.getId(),
38407           " "));
38408       System.out.flush();
38409       output = new String(baos.toByteArray());
38410 
38411       systemOut.println(output);
38412 
38413       System.setOut(systemOut);
38414 
38415       outputLines = GrouperClientUtils.splitTrim(output, "\n");
38416 
38417       assertEquals(1, outputLines.length);
38418 
38419       pattern = Pattern.compile("^Success: (T|F), queueOrTopicName: (.*), numberOfMessages: (.*)$");
38420       matcher = pattern.matcher(outputLines[0]);
38421 
38422       assertTrue(outputLines[0], matcher.matches());
38423 
38424       assertEquals(outputLines[0], "T", matcher.group(1));
38425       assertEquals(outputLines[0], "test_queue", matcher.group(2));
38426       assertEquals(outputLines[0], "2", matcher.group(3));
38427       
38428       assertTrue(GrouperClientWs.mostRecentRequest,
38429               GrouperClientWs.mostRecentRequest.contains("queueOrTopic"));
38430      assertFalse(GrouperClientWs.mostRecentRequest,
38431               GrouperClientWs.mostRecentRequest.contains("messageSystemName"));
38432 
38433     } finally {
38434       System.setOut(systemOut);
38435     }
38436 
38437   }
38438   
38439   /**
38440    * @throws Exception
38441    */
38442   public void testReceiveMessage() throws Exception {
38443 
38444     PrintStream systemOut = System.out;
38445 
38446     ByteArrayOutputStream baos = new ByteArrayOutputStream();
38447     System.setOut(new PrintStream(baos));
38448     String output = null;
38449     String[] outputLines = null;
38450     Pattern pattern = null;
38451     Matcher matcher = null;
38452     try {
38453 
38454       GrouperSession grouperSession = GrouperSession.startRootSession();
38455       GrouperBuiltinMessagingSystem.createQueue("test_queue");
38456       GrouperBuiltinMessagingSystem.allowSendToQueue("test_queue", SubjectTestHelper.SUBJ0);
38457       GrouperBuiltinMessagingSystem.allowReceiveFromQueue("test_queue", SubjectTestHelper.SUBJ0);
38458       
38459       GrouperSession.start(SubjectTestHelper.SUBJ0);
38460       GrouperMessagingEngine.send(new GrouperMessageSendParam().assignQueueOrTopicName("test_queue")
38461     	        .addMessageBody("message body").assignQueueType(GrouperMessageQueueType.queue));
38462 
38463       GrouperClient.main(GrouperClientUtils.splitTrim(
38464           "--operation=receiveMessageWs --queueOrTopicName=test_queue --actAsSubjectId="+SubjectTestHelper.SUBJ0.getId(),
38465           " "));
38466       System.out.flush();
38467       output = new String(baos.toByteArray());
38468 
38469       systemOut.println(output);
38470 
38471       System.setOut(systemOut);
38472 
38473       outputLines = GrouperClientUtils.splitTrim(output, "\n");
38474 
38475       assertEquals(1, outputLines.length);
38476 
38477       pattern = Pattern.compile("^Success: (T|F), queueOrTopicName: (.*), numberOfMessages: (\\d+)$");
38478       matcher = pattern.matcher(outputLines[0]);
38479 
38480       assertTrue(outputLines[0], matcher.matches());
38481 
38482       assertEquals(outputLines[0], "T", matcher.group(1));
38483       assertEquals(outputLines[0], "test_queue", matcher.group(2));
38484       assertTrue(outputLines[0], Integer.valueOf(matcher.group(3)) >= 1);
38485       
38486       // ############################
38487       // max messages to receive at once
38488       GrouperMessagingEngine.send(new GrouperMessageSendParam().assignQueueOrTopicName("test_queue")
38489   	        .addMessageBody("message body").assignQueueType(GrouperMessageQueueType.queue));
38490       GrouperMessagingEngine.send(new GrouperMessageSendParam().assignQueueOrTopicName("test_queue")
38491     	        .addMessageBody("another message body").assignQueueType(GrouperMessageQueueType.queue));
38492       baos = new ByteArrayOutputStream();
38493 
38494       System.setOut(new PrintStream(baos));
38495 
38496       GrouperClient.main(GrouperClientUtils.splitTrim(
38497               "--operation=receiveMessageWs --queueOrTopicName=test_queue --maxMessagesToReceiveAtOnce=1 --actAsSubjectId="+SubjectTestHelper.SUBJ0.getId(),
38498               " "));
38499       System.out.flush();
38500       output = new String(baos.toByteArray());
38501 
38502       systemOut.println(output);
38503 
38504       System.setOut(systemOut);
38505 
38506       outputLines = GrouperClientUtils.splitTrim(output, "\n");
38507 
38508       assertEquals(1, outputLines.length);
38509 
38510       matcher = pattern.matcher(outputLines[0]);
38511 
38512       assertTrue(outputLines[0], matcher.matches());
38513 
38514       assertEquals(outputLines[0], "T", matcher.group(1));
38515       assertEquals(outputLines[0], "test_queue", matcher.group(2));
38516       assertTrue(outputLines[0], Integer.valueOf(matcher.group(3)) == 1); // one message is received only because maxMessagesToReceiveAtOnce is set to 1
38517 
38518       assertTrue(GrouperClientWs.mostRecentRequest,
38519           GrouperClientWs.mostRecentRequest.contains("maxMessagesToReceiveAtOnce"));
38520 
38521     } finally {
38522       System.setOut(systemOut);
38523     }
38524 
38525   }
38526   
38527   /**
38528    * @throws Exception
38529    */
38530   public void testAcknowledgeMessage() throws Exception {
38531 
38532     PrintStream systemOut = System.out;
38533 
38534     ByteArrayOutputStream baos = new ByteArrayOutputStream();
38535     System.setOut(new PrintStream(baos));
38536     String output = null;
38537     String[] outputLines = null;
38538     Pattern pattern = null;
38539     Matcher matcher = null;
38540     try {
38541 
38542       GrouperSession grouperSession = GrouperSession.startRootSession();
38543       GrouperBuiltinMessagingSystem.createQueue("test_queue");
38544       GrouperBuiltinMessagingSystem.allowSendToQueue("test_queue", SubjectTestHelper.SUBJ0);
38545       GrouperBuiltinMessagingSystem.allowReceiveFromQueue("test_queue", SubjectTestHelper.SUBJ0);
38546       
38547       GrouperBuiltinMessagingSystem.createQueue("test_another_queue");
38548       GrouperBuiltinMessagingSystem.allowSendToQueue("test_another_queue", SubjectTestHelper.SUBJ0);
38549       GrouperBuiltinMessagingSystem.allowReceiveFromQueue("test_another_queue", SubjectTestHelper.SUBJ0);
38550       
38551       GrouperSession.start(SubjectTestHelper.SUBJ0);
38552       GrouperMessagingEngine.send(new GrouperMessageSendParam().assignQueueOrTopicName("test_queue")
38553     	        .addMessageBody("message body").assignQueueType(GrouperMessageQueueType.queue));
38554       
38555       GrouperMessageReceiveResult grouperMessageReceiveResult = GrouperMessagingEngine.receive(new GrouperMessageReceiveParam().assignQueueName("test_queue"));
38556       
38557       GrouperMessage grouperMessage = grouperMessageReceiveResult.getGrouperMessages().iterator().next();
38558 
38559       // mark as processed
38560       GrouperClient.main(GrouperClientUtils.splitTrim(
38561           "--operation=acknowledgeMessageWs --queueOrTopicName=test_queue "
38562           + "--acknowledgeType=mark_as_processed --messageIds="+grouperMessage.getId()+" --actAsSubjectId="+SubjectTestHelper.SUBJ0.getId(),
38563           " "));
38564       System.out.flush();
38565       output = new String(baos.toByteArray());
38566 
38567       systemOut.println(output);
38568 
38569       System.setOut(systemOut);
38570 
38571       outputLines = GrouperClientUtils.splitTrim(output, "\n");
38572 
38573       assertEquals(1, outputLines.length);
38574 
38575       pattern = Pattern.compile("^Success: (T|F), queueOrTopicName: (.*), numberOfMessages: (\\d+)$");
38576       matcher = pattern.matcher(outputLines[0]);
38577 
38578       assertTrue(outputLines[0], matcher.matches());
38579 
38580       assertEquals(outputLines[0], "T", matcher.group(1));
38581       assertEquals(outputLines[0], "test_queue", matcher.group(2));
38582       assertTrue(outputLines[0], Integer.valueOf(matcher.group(3)) >= 1);
38583       
38584       // ############################
38585       
38586       GrouperMessagingEngine.send(new GrouperMessageSendParam().assignQueueOrTopicName("test_queue")
38587   	        .addMessageBody("message test body").assignQueueType(GrouperMessageQueueType.queue));
38588     
38589       grouperMessageReceiveResult = GrouperMessagingEngine.receive(new GrouperMessageReceiveParam().assignQueueName("test_queue"));
38590       grouperMessage = grouperMessageReceiveResult.getGrouperMessages().iterator().next();
38591 
38592       baos = new ByteArrayOutputStream();
38593 
38594       System.setOut(new PrintStream(baos));
38595 
38596       GrouperClient.main(GrouperClientUtils.splitTrim(
38597               "--operation=acknowledgeMessageWs --queueOrTopicName=test_queue "
38598               + "--acknowledgeType=send_to_another_queue --anotherQueueOrTopicName=test_another_queue --anotherQueueOrTopic=queue"
38599               + " --messageIds="+grouperMessage.getId()+" --actAsSubjectId="+SubjectTestHelper.SUBJ0.getId(),
38600               " "));
38601       System.out.flush();
38602       output = new String(baos.toByteArray());
38603 
38604       systemOut.println(output);
38605 
38606       System.setOut(systemOut);
38607 
38608       outputLines = GrouperClientUtils.splitTrim(output, "\n");
38609 
38610       assertEquals(1, outputLines.length);
38611 
38612       matcher = pattern.matcher(outputLines[0]);
38613 
38614       assertTrue(outputLines[0], matcher.matches());
38615 
38616       assertEquals(outputLines[0], "T", matcher.group(1));
38617       assertEquals(outputLines[0], "test_queue", matcher.group(2));
38618       assertTrue(outputLines[0], Integer.valueOf(matcher.group(3)) == 1); // one message is received only because maxMessagesToReceiveAtOnce is set to 1
38619       
38620     } finally {
38621       System.setOut(systemOut);
38622     }
38623 
38624   }
38625 
38626   /**
38627    * @throws Exception
38628    */
38629   public void testFindExternalSubjects() throws Exception {
38630   
38631     // set some stuff to query
38632     GrouperSession grouperSession = GrouperSession.startRootSession();
38633 
38634     //make sure you have jabber enabled in grouper.properties
38635     ExternalSubjectSave assignName = new ExternalSubjectSave(grouperSession).assignEmail("a@b.c")
38636         .assignIdentifier("a_ident@b.c").assignName("Some Name");
38637     
38638     boolean hasJabber = StringUtils.equals(GrouperConfig.retrieveConfig().propertyValueString("externalSubjects.attributes.jabber.systemName"), "jabber");
38639 
38640     if (hasJabber) {
38641       assignName.addAttribute("jabber", "a_jabber@b.c");
38642     }
38643     ExternalSubject externalSubject = assignName.save();
38644     
38645   
38646     PrintStream systemOut = System.out;
38647   
38648     ByteArrayOutputStream baos = new ByteArrayOutputStream();
38649     System.setOut(new PrintStream(baos));
38650   
38651     try {
38652   
38653       GrouperClient
38654           .main(GrouperClientUtils
38655               .splitTrim(
38656                   "--operation=findExternalSubjectsWs --identifier=a_ident@b.c",
38657                   " "));
38658       System.out.flush();
38659       String output = new String(baos.toByteArray());
38660   
38661       System.setOut(systemOut);
38662   
38663       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
38664   
38665       Pattern pattern = Pattern
38666           .compile("^Index (\\d+): identifier: (.+), name: (.+)$");
38667       Matcher matcher = pattern.matcher(outputLines[0]);
38668   
38669       assertEquals(output, 1, outputLines.length);
38670       assertTrue(outputLines[0], matcher.matches());
38671   
38672       assertEquals(output, "0", matcher.group(1));
38673       assertEquals(output, "a_ident@b.c", matcher.group(2));
38674       assertEquals(output, "Some Name", matcher.group(3));
38675   
38676       // #####################################################
38677       // run with invalid args
38678       baos = new ByteArrayOutputStream();
38679       System.setOut(new PrintStream(baos));
38680   
38681       // test a command line template
38682       try {
38683         GrouperClient
38684             .main(GrouperClientUtils
38685                 .splitTrim(
38686                     "--operation=findExternalSubjectsWs --identifier=a_ident@b.c --ousdfsdfate=${index}",
38687                     " "));
38688       } catch (Exception e) {
38689         assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
38690       }
38691       System.out.flush();
38692   
38693       System.setOut(systemOut);
38694   
38695       // #####################################################
38696       // run with custom template
38697       baos = new ByteArrayOutputStream();
38698       System.setOut(new PrintStream(baos));
38699   
38700       // test a command line template
38701       GrouperClient
38702           .main(GrouperClientUtils
38703               .splitTrim(
38704                   "--operation=findExternalSubjectsWs --identifier=a_ident@b.c --outputTemplate=${index}",
38705                   " "));
38706   
38707       System.out.flush();
38708   
38709       output = new String(baos.toByteArray());
38710   
38711       System.setOut(systemOut);
38712   
38713       assertEquals("0", output);
38714   
38715       // #####################################################
38716       // run again, with params
38717       baos = new ByteArrayOutputStream();
38718       System.setOut(new PrintStream(baos));
38719   
38720       GrouperClient
38721           .main(GrouperClientUtils
38722               .splitTrim(
38723                   "--operation=findExternalSubjectsWs --identifier=a_ident@b.c --paramName0=whatever --paramValue0=someValue",
38724                   " "));
38725       System.out.flush();
38726       output = new String(baos.toByteArray());
38727   
38728       System.setOut(systemOut);
38729   
38730       outputLines = GrouperClientUtils.splitTrim(output, "\n");
38731   
38732       matcher = pattern.matcher(outputLines[0]);
38733   
38734       assertEquals(output, 1, outputLines.length);
38735       assertTrue(outputLines[0], matcher.matches());
38736   
38737       assertEquals(output, "0", matcher.group(1));
38738       assertEquals(output, "a_ident@b.c", matcher.group(2));
38739       assertEquals(output, "Some Name", matcher.group(3));
38740   
38741       assertTrue(GrouperClientWs.mostRecentRequest.contains("whatever")
38742           && GrouperClientWs.mostRecentRequest.contains("someValue"));
38743     
38744   
38745     } finally {
38746       System.setOut(systemOut);
38747     }
38748   
38749   }
38750 
38751   /**
38752    * @throws Exception
38753    */
38754   public void testExternalSubjectDelete() throws Exception {
38755     
38756     // set some stuff to query
38757     GrouperSession grouperSession = GrouperSession.startRootSession();
38758 
38759     //make sure you have jabber enabled in grouper.properties
38760     ExternalSubjectSave assignName = new ExternalSubjectSave(grouperSession).assignEmail("a@b.c")
38761         .assignIdentifier("a_ident@b.c").assignName("Some Name");
38762     
38763     boolean hasJabber = StringUtils.equals(GrouperConfig.retrieveConfig().propertyValueString("externalSubjects.attributes.jabber.systemName"), "jabber");
38764 
38765     if (hasJabber) {
38766       assignName.addAttribute("jabber", "a_jabber@b.c");
38767     }
38768     ExternalSubject externalSubject = assignName.save();
38769 
38770     
38771     PrintStream systemOut = System.out;
38772   
38773     ByteArrayOutputStream baos = new ByteArrayOutputStream();
38774     System.setOut(new PrintStream(baos));
38775   
38776     try {
38777   
38778       GrouperClient.main(GrouperClientUtils.splitTrim(
38779           "--operation=externalSubjectDeleteWs --identifiers=a_ident@b.c", " "));
38780       System.out.flush();
38781       String output = new String(baos.toByteArray());
38782   
38783       System.setOut(systemOut);
38784   
38785       String[] outputLines = GrouperClientUtils.splitTrim(output, "\n");
38786   
38787       Pattern pattern = Pattern
38788           .compile("^Index (\\d+): success: T: code: ([A-Z_]+): identifier: (.+): name:\\s?(.*)$");
38789       Matcher matcher = pattern.matcher(outputLines[0]);
38790   
38791       assertTrue(outputLines[0], matcher.matches());
38792   
38793       assertEquals("0", matcher.group(1));
38794       assertEquals("SUCCESS", matcher.group(2));
38795       assertEquals("a_ident@b.c", matcher.group(3));
38796       assertEquals("Some Name", matcher.group(4));
38797   
38798       // #####################################################
38799       // run again, should be already deleted
38800       baos = new ByteArrayOutputStream();
38801       System.setOut(new PrintStream(baos));
38802   
38803       GrouperClient.main(GrouperClientUtils.splitTrim(
38804           "--operation=externalSubjectDeleteWs --identifiers=a_ident@b.c", " "));
38805       System.out.flush();
38806       output = new String(baos.toByteArray());
38807   
38808       System.setOut(systemOut);
38809   
38810       outputLines = GrouperClientUtils.splitTrim(output, "\n");
38811   
38812       matcher = pattern.matcher(outputLines[0]);
38813   
38814       assertTrue(outputLines[0], matcher.matches());
38815   
38816       assertEquals("0", matcher.group(1));
38817       assertEquals("SUCCESS_EXTERNAL_SUBJECT_NOT_FOUND", matcher.group(2));
38818       assertEquals("a_ident@b.c", matcher.group(3));
38819       assertTrue(matcher.group(4), StringUtils.isBlank(matcher.group(4)));
38820   
38821       // #####################################################
38822       // run with invalid args
38823       baos = new ByteArrayOutputStream();
38824       System.setOut(new PrintStream(baos));
38825   
38826       // test a command line template
38827       try {
38828         GrouperClient
38829             .main(GrouperClientUtils
38830                 .splitTrim(
38831                     "--operation=externalSubjectDeleteWs --identifiers=a_ident@b.c --ousdfsdfate=${index}",
38832                     " "));
38833       } catch (Exception e) {
38834         assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
38835       }
38836       System.out.flush();
38837   
38838       System.setOut(systemOut);
38839   
38840       // #####################################################
38841       // run with custom template
38842       baos = new ByteArrayOutputStream();
38843       System.setOut(new PrintStream(baos));
38844   
38845       // test a command line template
38846       GrouperClient
38847           .main(GrouperClientUtils
38848               .splitTrim(
38849                   "--operation=externalSubjectDeleteWs --identifiers=a_ident@b.c --outputTemplate=${index}",
38850                   " "));
38851   
38852       System.out.flush();
38853   
38854       output = new String(baos.toByteArray());
38855   
38856       System.setOut(systemOut);
38857   
38858       assertEquals("0", output);
38859   
38860       // #####################################################
38861       // run again, with txType
38862       baos = new ByteArrayOutputStream();
38863       System.setOut(new PrintStream(baos));
38864   
38865       GrouperClient.main(GrouperClientUtils.splitTrim(
38866           "--operation=externalSubjectDeleteWs --identifiers=a_ident@b.c --txType=NONE",
38867           " "));
38868       System.out.flush();
38869       output = new String(baos.toByteArray());
38870   
38871       System.setOut(systemOut);
38872   
38873       outputLines = GrouperClientUtils.splitTrim(output, "\n");
38874   
38875       matcher = pattern.matcher(outputLines[0]);
38876   
38877       assertTrue(outputLines[0], matcher.matches());
38878   
38879       assertEquals("0", matcher.group(1));
38880       assertEquals("SUCCESS_EXTERNAL_SUBJECT_NOT_FOUND", matcher.group(2));
38881       assertEquals("a_ident@b.c", matcher.group(3));
38882       assertTrue(matcher.group(4), StringUtils.isBlank(matcher.group(4)));
38883   
38884       assertTrue(GrouperClientWs.mostRecentRequest,
38885           GrouperClientWs.mostRecentRequest.contains("txType")
38886               && GrouperClientWs.mostRecentRequest.contains("NONE"));
38887   
38888       // #####################################################
38889       // run again, with params
38890       baos = new ByteArrayOutputStream();
38891       System.setOut(new PrintStream(baos));
38892   
38893       GrouperClient
38894           .main(GrouperClientUtils
38895               .splitTrim(
38896                   "--operation=externalSubjectDeleteWs --identifiers=a_ident@b.c --paramName0=whatever --paramValue0=someValue",
38897                   " "));
38898       System.out.flush();
38899       output = new String(baos.toByteArray());
38900   
38901       System.setOut(systemOut);
38902   
38903       outputLines = GrouperClientUtils.splitTrim(output, "\n");
38904   
38905       matcher = pattern.matcher(outputLines[0]);
38906   
38907       assertTrue(outputLines[0], matcher.matches());
38908   
38909       assertEquals("0", matcher.group(1));
38910       assertEquals("SUCCESS_EXTERNAL_SUBJECT_NOT_FOUND", matcher.group(2));
38911       assertEquals("a_ident@b.c", matcher.group(3));
38912       assertTrue(matcher.group(4), StringUtils.isBlank(matcher.group(4)));
38913   
38914       assertTrue(GrouperClientWs.mostRecentRequest.contains("whatever")
38915           && GrouperClientWs.mostRecentRequest.contains("someValue"));
38916   
38917     } finally {
38918       System.setOut(systemOut);
38919     }
38920   
38921   }
38922 
38923   /**
38924      * @throws Exception
38925      */
38926     public void testExternalSubjectSave() throws Exception {
38927   //sdf
38928       PrintStream systemOut = System.out;
38929   
38930       ByteArrayOutputStream baos = new ByteArrayOutputStream();
38931       System.setOut(new PrintStream(baos));
38932       String output = null;
38933       String[] outputLines = null;
38934       Pattern pattern = null;
38935       Matcher matcher = null;
38936       
38937       try {
38938 
38939         // ##########################
38940         //try with name with slash
38941   
38942         baos = new ByteArrayOutputStream();
38943         System.setOut(new PrintStream(baos));
38944   
38945         GrouperClient.main(GrouperClientUtils.splitTrim(
38946             "--operation=externalSubjectSaveWs --identifier=b_ident@c.d --name=AnotherName --attributeName0=jabber --attributeValue0=b_jabber@c.d", " "));
38947         System.out.flush();
38948         output = new String(baos.toByteArray());
38949   
38950         System.setOut(systemOut);
38951   
38952         outputLines = GrouperClientUtils.splitTrim(output, "\n");
38953   
38954         pattern = Pattern.compile("^Success: T: code: ([A-Z_]+): identifier: (.+): name: (.+)$");
38955         matcher = pattern.matcher(outputLines[0]);
38956   
38957         assertTrue(outputLines[0], matcher.matches());
38958   
38959         assertEquals("SUCCESS_INSERTED", matcher.group(1));
38960         assertEquals("b_ident@c.d", matcher.group(2));
38961         assertEquals("AnotherName", matcher.group(3));
38962   
38963         // #####################################################
38964         // run again, should be already added
38965         baos = new ByteArrayOutputStream();
38966         System.setOut(new PrintStream(baos));
38967   
38968         GrouperClient.main(GrouperClientUtils.splitTrim(
38969             "--operation=externalSubjectSaveWs --identifier=b_ident@c.d --name=AnotherName --attributeName0=jabber --attributeValue0=b_jabber@c.d", " "));
38970         System.out.flush();
38971         output = new String(baos.toByteArray());
38972   
38973         System.setOut(systemOut);
38974   
38975         outputLines = GrouperClientUtils.splitTrim(output, "\n");
38976   
38977         matcher = pattern.matcher(outputLines[0]);
38978   
38979         assertTrue(outputLines[0], matcher.matches());
38980   
38981         assertEquals("SUCCESS_NO_CHANGES_NEEDED", matcher.group(1));
38982         assertEquals("b_ident@c.d", matcher.group(2));
38983         assertEquals("AnotherName", matcher.group(3));
38984   
38985         // #####################################################
38986         // run with invalid args
38987         baos = new ByteArrayOutputStream();
38988         System.setOut(new PrintStream(baos));
38989   
38990         // test a command line template
38991         try {
38992           GrouperClient
38993               .main(GrouperClientUtils
38994                   .splitTrim(
38995                       "--operation=externalSubjectSaveWs --identifier=b_ident@c.d --name=AnotherName --attributeName0=jabber --attributeValue0=b_jabber@c.d --ousdfsdfate=${index}", 
38996                       " "));
38997         } catch (Exception e) {
38998           assertTrue(e.getMessage(), e.getMessage().contains("ousdfsdfate"));
38999         }
39000         System.out.flush();
39001   
39002         System.setOut(systemOut);
39003   
39004         // #####################################################
39005         // run with custom template
39006         baos = new ByteArrayOutputStream();
39007         System.setOut(new PrintStream(baos));
39008   
39009         // test a command line template
39010         GrouperClient
39011             .main(GrouperClientUtils
39012                 .splitTrim(
39013                     "--operation=externalSubjectSaveWs --identifier=b_ident@c.d --name=AnotherName --attributeName0=jabber --attributeValue0=b_jabber@c.d --outputTemplate=${index}", 
39014                     " "));
39015   
39016         System.out.flush();
39017   
39018         output = new String(baos.toByteArray());
39019   
39020         System.setOut(systemOut);
39021   
39022         assertEquals("0", output);
39023   
39024         // #####################################################
39025         // run again, with txType
39026         baos = new ByteArrayOutputStream();
39027         System.setOut(new PrintStream(baos));
39028   
39029         GrouperClient.main(GrouperClientUtils.splitTrim(
39030             "--operation=externalSubjectSaveWs --identifier=b_ident@c.d --name=AnotherName --attributeName0=jabber --attributeValue0=b_jabber@c.d --txType=NONE", 
39031             " "));
39032             
39033         System.out.flush();
39034         output = new String(baos.toByteArray());
39035   
39036         System.setOut(systemOut);
39037   
39038         outputLines = GrouperClientUtils.splitTrim(output, "\n");
39039   
39040         matcher = pattern.matcher(outputLines[0]);
39041   
39042         assertTrue(outputLines[0], matcher.matches());
39043   
39044         assertEquals("SUCCESS_NO_CHANGES_NEEDED", matcher.group(1));
39045         assertEquals("b_ident@c.d", matcher.group(2));
39046         assertEquals("AnotherName", matcher.group(3));
39047   
39048         assertTrue(GrouperClientWs.mostRecentRequest,
39049             GrouperClientWs.mostRecentRequest.contains("txType")
39050                 && GrouperClientWs.mostRecentRequest.contains("NONE")
39051                 && !GrouperClientWs.mostRecentRequest
39052                     .contains("includeGroupDetail"));
39053   
39054         // #####################################################
39055         // run again, with saveMode
39056         baos = new ByteArrayOutputStream();
39057         System.setOut(new PrintStream(baos));
39058   
39059         GrouperClient.main(GrouperClientUtils.splitTrim(
39060             "--operation=externalSubjectSaveWs --identifier=b_ident@c.d --name=AnotherName --attributeName0=jabber --attributeValue0=b_jabber@c.d --saveMode=UPDATE", 
39061             " "));
39062         System.out.flush();
39063         output = new String(baos.toByteArray());
39064   
39065         System.setOut(systemOut);
39066   
39067         outputLines = GrouperClientUtils.splitTrim(output, "\n");
39068   
39069         matcher = pattern.matcher(outputLines[0]);
39070   
39071         assertTrue(outputLines[0], matcher.matches());
39072   
39073         assertEquals("SUCCESS_NO_CHANGES_NEEDED", matcher.group(1));
39074         assertEquals("b_ident@c.d", matcher.group(2));
39075         assertEquals("AnotherName", matcher.group(3));
39076   
39077         assertTrue(GrouperClientWs.mostRecentRequest.contains("saveMode")
39078             && GrouperClientWs.mostRecentRequest.contains("UPDATE"));
39079   
39080         // #####################################################
39081         // run again, with params
39082         baos = new ByteArrayOutputStream();
39083         System.setOut(new PrintStream(baos));
39084 
39085         GrouperClient
39086             .main(GrouperClientUtils
39087                 .splitTrim(
39088                     "--operation=externalSubjectSaveWs --identifier=b_ident@c.d --name=AnotherName --attributeName0=jabber --attributeValue0=b_jabber@c.d --paramName0=whatever --paramValue0=someValue", 
39089                     " "));
39090         System.out.flush();
39091         output = new String(baos.toByteArray());
39092 
39093         System.setOut(systemOut);
39094 
39095         outputLines = GrouperClientUtils.splitTrim(output, "\n");
39096 
39097         matcher = pattern.matcher(outputLines[0]);
39098 
39099         assertTrue(outputLines[0], matcher.matches());
39100 
39101         assertEquals("SUCCESS_NO_CHANGES_NEEDED", matcher.group(1));
39102         assertEquals("b_ident@c.d", matcher.group(2));
39103         assertEquals("AnotherName", matcher.group(3));
39104 
39105         assertTrue(GrouperClientWs.mostRecentRequest.contains("whatever")
39106             && GrouperClientWs.mostRecentRequest.contains("someValue"));
39107 
39108       } finally {
39109         System.setOut(systemOut);
39110       }
39111   
39112     }
39113   
39114 }